wxPython/src/msw/_controls_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_wxTextUrlEvent swig_types[0]
1342 #define  SWIGTYPE_p_wxSizer swig_types[1]
1343 #define  SWIGTYPE_p_wxCheckBox swig_types[2]
1344 #define  SWIGTYPE_p_wxPyTreeCtrl swig_types[3]
1345 #define  SWIGTYPE_p_wxEvent swig_types[4]
1346 #define  SWIGTYPE_p_wxGenericDirCtrl swig_types[5]
1347 #define  SWIGTYPE_p_bool swig_types[6]
1348 #define  SWIGTYPE_p_wxItemContainer swig_types[7]
1349 #define  SWIGTYPE_p_wxPyListCtrl swig_types[8]
1350 #define  SWIGTYPE_p_wxPyTreeItemData swig_types[9]
1351 #define  SWIGTYPE_p_wxDirFilterListCtrl swig_types[10]
1352 #define  SWIGTYPE_p_wxStaticLine swig_types[11]
1353 #define  SWIGTYPE_p_wxControl swig_types[12]
1354 #define  SWIGTYPE_p_wxPyControl swig_types[13]
1355 #define  SWIGTYPE_p_wxGauge swig_types[14]
1356 #define  SWIGTYPE_p_wxToolBarBase swig_types[15]
1357 #define  SWIGTYPE_p_wxFont swig_types[16]
1358 #define  SWIGTYPE_p_wxToggleButton swig_types[17]
1359 #define  SWIGTYPE_p_wxRadioButton swig_types[18]
1360 #define  SWIGTYPE_p_wxChoice swig_types[19]
1361 #define  SWIGTYPE_p_wxMemoryDC swig_types[20]
1362 #define  SWIGTYPE_ptrdiff_t swig_types[21]
1363 #define  SWIGTYPE_std__ptrdiff_t swig_types[22]
1364 #define  SWIGTYPE_p_wxListItemAttr swig_types[23]
1365 #define  SWIGTYPE_p_void swig_types[24]
1366 #define  SWIGTYPE_p_int swig_types[25]
1367 #define  SWIGTYPE_p_wxSize swig_types[26]
1368 #define  SWIGTYPE_p_wxDC swig_types[27]
1369 #define  SWIGTYPE_p_wxListView swig_types[28]
1370 #define  SWIGTYPE_p_wxIcon swig_types[29]
1371 #define  SWIGTYPE_p_wxVisualAttributes swig_types[30]
1372 #define  SWIGTYPE_p_wxTextCtrl swig_types[31]
1373 #define  SWIGTYPE_p_wxNotebook swig_types[32]
1374 #define  SWIGTYPE_p_wxChoicebook swig_types[33]
1375 #define  SWIGTYPE_p_wxNotifyEvent swig_types[34]
1376 #define  SWIGTYPE_p_wxArrayString swig_types[35]
1377 #define  SWIGTYPE_p_form_ops_t swig_types[36]
1378 #define  SWIGTYPE_p_wxListbook swig_types[37]
1379 #define  SWIGTYPE_p_wxStaticBitmap swig_types[38]
1380 #define  SWIGTYPE_p_wxSlider swig_types[39]
1381 #define  SWIGTYPE_p_wxStaticBox swig_types[40]
1382 #define  SWIGTYPE_p_wxArrayInt swig_types[41]
1383 #define  SWIGTYPE_p_wxContextHelp swig_types[42]
1384 #define  SWIGTYPE_p_long swig_types[43]
1385 #define  SWIGTYPE_p_wxDuplexMode swig_types[44]
1386 #define  SWIGTYPE_p_wxBookCtrlBase swig_types[45]
1387 #define  SWIGTYPE_p_wxEvtHandler swig_types[46]
1388 #define  SWIGTYPE_p_wxListEvent swig_types[47]
1389 #define  SWIGTYPE_p_wxCheckListBox swig_types[48]
1390 #define  SWIGTYPE_p_wxListBox swig_types[49]
1391 #define  SWIGTYPE_p_wxSpinButton swig_types[50]
1392 #define  SWIGTYPE_p_wxButton swig_types[51]
1393 #define  SWIGTYPE_p_wxBitmapButton swig_types[52]
1394 #define  SWIGTYPE_p_wxRect swig_types[53]
1395 #define  SWIGTYPE_p_wxContextHelpButton swig_types[54]
1396 #define  SWIGTYPE_p_wxRadioBox swig_types[55]
1397 #define  SWIGTYPE_p_wxScrollBar swig_types[56]
1398 #define  SWIGTYPE_p_char swig_types[57]
1399 #define  SWIGTYPE_p_wxComboBox swig_types[58]
1400 #define  SWIGTYPE_p_wxTreeItemId swig_types[59]
1401 #define  SWIGTYPE_p_wxHelpEvent swig_types[60]
1402 #define  SWIGTYPE_p_wxListItem swig_types[61]
1403 #define  SWIGTYPE_p_wxNotebookSizer swig_types[62]
1404 #define  SWIGTYPE_p_wxSpinEvent swig_types[63]
1405 #define  SWIGTYPE_p_wxGenericDragImage swig_types[64]
1406 #define  SWIGTYPE_p_wxSpinCtrl swig_types[65]
1407 #define  SWIGTYPE_p_wxPaperSize swig_types[66]
1408 #define  SWIGTYPE_p_wxImageList swig_types[67]
1409 #define  SWIGTYPE_p_wxHelpProvider swig_types[68]
1410 #define  SWIGTYPE_p_wxTextAttr swig_types[69]
1411 #define  SWIGTYPE_p_wxSimpleHelpProvider swig_types[70]
1412 #define  SWIGTYPE_p_wxChoicebookEvent swig_types[71]
1413 #define  SWIGTYPE_p_wxListbookEvent swig_types[72]
1414 #define  SWIGTYPE_p_wxNotebookEvent swig_types[73]
1415 #define  SWIGTYPE_p_wxPoint swig_types[74]
1416 #define  SWIGTYPE_p_wxObject swig_types[75]
1417 #define  SWIGTYPE_p_wxCursor swig_types[76]
1418 #define  SWIGTYPE_p_wxKeyEvent swig_types[77]
1419 #define  SWIGTYPE_p_unsigned_long swig_types[78]
1420 #define  SWIGTYPE_p_wxWindow swig_types[79]
1421 #define  SWIGTYPE_p_wxString swig_types[80]
1422 #define  SWIGTYPE_p_wxBitmap swig_types[81]
1423 #define  SWIGTYPE_unsigned_int swig_types[82]
1424 #define  SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define  SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define  SWIGTYPE_p_wxMouseEvent swig_types[85]
1427 #define  SWIGTYPE_p_wxBookCtrlBaseEvent swig_types[86]
1428 #define  SWIGTYPE_p_wxTreeEvent swig_types[87]
1429 #define  SWIGTYPE_p_wxCommandEvent swig_types[88]
1430 #define  SWIGTYPE_p_wxStaticText swig_types[89]
1431 #define  SWIGTYPE_p_wxControlWithItems swig_types[90]
1432 #define  SWIGTYPE_p_wxToolBarToolBase swig_types[91]
1433 #define  SWIGTYPE_p_wxColour swig_types[92]
1434 #define  SWIGTYPE_p_wxToolBar swig_types[93]
1435 #define  SWIGTYPE_p_wxBookCtrlSizer swig_types[94]
1436 #define  SWIGTYPE_p_wxValidator swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443               @(target):= _controls_.so
1444   ------------------------------------------------*/
1445 #define SWIG_init    init_controls_
1446
1447 #define SWIG_name    "_controls_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451
1452  static const wxString wxPyPanelNameStr(wxPanelNameStr);
1453  static const wxString wxPyEmptyString(wxEmptyString);
1454  static const wxString wxPyControlNameStr(wxControlNameStr);
1455
1456     const wxArrayString wxPyEmptyStringArray;
1457
1458  static const wxString wxPyButtonNameStr(wxButtonNameStr);
1459
1460   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1461 #define SWIG_From_int PyInt_FromLong
1462 /*@@*/
1463
1464
1465 #include <limits.h>
1466
1467
1468 SWIGINTERN int
1469   SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470                         const char *errmsg)
1471 {
1472   if (value < min_value) {
1473     if (errmsg) {
1474       PyErr_Format(PyExc_OverflowError,
1475                    "value %ld is less than '%s' minimum %ld",
1476                    value, errmsg, min_value);
1477     }
1478     return 0;
1479   } else if (value > max_value) {
1480     if (errmsg) {
1481       PyErr_Format(PyExc_OverflowError,
1482                    "value %ld is greater than '%s' maximum %ld",
1483                    value, errmsg, max_value);
1484     }
1485     return 0;
1486   }
1487   return 1;
1488 }
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_long(PyObject* obj, long* val)
1493 {
1494     if (PyNumber_Check(obj)) {
1495         if (val) *val = PyInt_AsLong(obj);
1496         return 1;
1497     }
1498     else {
1499         SWIG_type_error("number", obj);
1500     }
1501     return 0;
1502 }
1503
1504
1505 #if INT_MAX != LONG_MAX
1506 SWIGINTERN int
1507   SWIG_AsVal_int(PyObject *obj, int *val)
1508 {
1509   const char* errmsg = val ? "int" : (char*)0;
1510   long v;
1511   if (SWIG_AsVal_long(obj, &v)) {
1512     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1513       if (val) *val = (int)(v);
1514       return 1;
1515     } else {
1516       return 0;
1517     }
1518   } else {
1519     PyErr_Clear();
1520   }
1521   if (val) {
1522     SWIG_type_error(errmsg, obj);
1523   }
1524   return 0;
1525 }
1526 #else
1527 SWIGINTERNSHORT int
1528   SWIG_AsVal_int(PyObject *obj, int *val)
1529 {
1530   return SWIG_AsVal_long(obj,(long*)val);
1531 }
1532 #endif
1533
1534
1535 SWIGINTERNSHORT int
1536 SWIG_As_int(PyObject* obj)
1537 {
1538   int v;
1539   if (!SWIG_AsVal_int(obj, &v)) {
1540     /*
1541       this is needed to make valgrind/purify happier.
1542      */
1543     memset((void*)&v, 0, sizeof(int));
1544   }
1545   return v;
1546 }
1547
1548
1549 SWIGINTERNSHORT long
1550 SWIG_As_long(PyObject* obj)
1551 {
1552   long v;
1553   if (!SWIG_AsVal_long(obj, &v)) {
1554     /*
1555       this is needed to make valgrind/purify happier.
1556      */
1557     memset((void*)&v, 0, sizeof(long));
1558   }
1559   return v;
1560 }
1561
1562
1563 SWIGINTERNSHORT int
1564 SWIG_Check_int(PyObject* obj)
1565 {
1566   return SWIG_AsVal_int(obj, (int*)0);
1567 }
1568
1569
1570 SWIGINTERNSHORT int
1571 SWIG_Check_long(PyObject* obj)
1572 {
1573   return SWIG_AsVal_long(obj, (long*)0);
1574 }
1575
1576  static const wxString wxPyCheckBoxNameStr(wxCheckBoxNameStr);
1577
1578 SWIGINTERN int
1579   SWIG_AsVal_bool(PyObject *obj, bool *val)
1580 {
1581   if (obj == Py_True) {
1582     if (val) *val = true;
1583     return 1;
1584   }
1585   if (obj == Py_False) {
1586     if (val) *val = false;
1587     return 1;
1588   }
1589   int res = 0;
1590   if (SWIG_AsVal_int(obj, &res)) {
1591     if (val) *val = res ? true : false;
1592     return 1;
1593   } else {
1594     PyErr_Clear();
1595   }
1596   if (val) {
1597     SWIG_type_error("bool", obj);
1598   }
1599   return 0;
1600 }
1601
1602
1603 SWIGINTERNSHORT bool
1604 SWIG_As_bool(PyObject* obj)
1605 {
1606   bool v;
1607   if (!SWIG_AsVal_bool(obj, &v)) {
1608     /*
1609       this is needed to make valgrind/purify happier.
1610      */
1611     memset((void*)&v, 0, sizeof(bool));
1612   }
1613   return v;
1614 }
1615
1616
1617 SWIGINTERNSHORT int
1618 SWIG_Check_bool(PyObject* obj)
1619 {
1620   return SWIG_AsVal_bool(obj, (bool*)0);
1621 }
1622
1623  static const wxString wxPyChoiceNameStr(wxChoiceNameStr);
1624  static const wxString wxPyComboBoxNameStr(wxComboBoxNameStr);
1625
1626   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1627 #define SWIG_From_long PyInt_FromLong
1628 /*@@*/
1629
1630
1631   static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632     PyObject*   o2;
1633     PyObject*   o3;
1634
1635     if (!target) {
1636         target = o;
1637     } else if (target == Py_None) {
1638         Py_DECREF(Py_None);
1639         target = o;
1640     } else {
1641         if (!PyTuple_Check(target)) {
1642             o2 = target;
1643             target = PyTuple_New(1);
1644             PyTuple_SetItem(target, 0, o2);
1645         }
1646         o3 = PyTuple_New(1);
1647         PyTuple_SetItem(o3, 0, o);
1648
1649         o2 = target;
1650         target = PySequence_Concat(o2, o3);
1651         Py_DECREF(o2);
1652         Py_DECREF(o3);
1653     }
1654     return target;
1655   }
1656
1657
1658  static const wxString wxPyGaugeNameStr(wxGaugeNameStr);
1659  static const wxString wxPyStaticBitmapNameStr(wxStaticBitmapNameStr);
1660  static const wxString wxPyStaticBoxNameStr(wxStaticBoxNameStr);
1661  static const wxString wxPyStaticTextNameStr(wxStaticTextNameStr);
1662
1663 #include <wx/checklst.h>
1664
1665
1666  static const wxString wxPyListBoxNameStr(wxListBoxNameStr);
1667 static void wxListBox_Insert(wxListBox *self,wxString const &item,int pos,PyObject *clientData=NULL){
1668             if (clientData) {
1669                 wxPyClientData* data = new wxPyClientData(clientData);
1670                 self->Insert(item, pos, data);
1671             } else
1672                 self->Insert(item, pos);
1673         }
1674 static PyObject *wxListBox_GetSelections(wxListBox *self){
1675           wxArrayInt lst;
1676           self->GetSelections(lst);
1677           PyObject *tup = PyTuple_New(lst.GetCount());
1678           for(size_t i=0; i<lst.GetCount(); i++) {
1679               PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
1680           }
1681           return tup;
1682       }
1683 static void wxListBox_SetItemForegroundColour(wxListBox *self,int item,wxColour const &c){
1684             #ifdef __WXMSW__
1685                  if (self->GetWindowStyle() & wxLB_OWNERDRAW)
1686                      self->GetItem(item)->SetTextColour(c);
1687             #endif
1688         }
1689 static void wxListBox_SetItemBackgroundColour(wxListBox *self,int item,wxColour const &c){
1690             #ifdef __WXMSW__
1691                  if (self->GetWindowStyle() & wxLB_OWNERDRAW)
1692                      self->GetItem(item)->SetBackgroundColour(c);
1693             #endif
1694         }
1695 static void wxListBox_SetItemFont(wxListBox *self,int item,wxFont const &f){
1696             #ifdef __WXMSW__
1697                  if (self->GetWindowStyle() & wxLB_OWNERDRAW)
1698                      self->GetItem(item)->SetFont(f);
1699             #endif
1700         }
1701  static const wxString wxPyTextCtrlNameStr(wxTextCtrlNameStr);
1702
1703 SWIGINTERN int
1704 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1705 {
1706     long v = 0;
1707     if (SWIG_AsVal_long(obj, &v) && v < 0) {
1708         SWIG_type_error("unsigned number", obj);
1709     }
1710     else if (val)
1711         *val = (unsigned long)v;
1712     return 1;
1713 }
1714
1715
1716 SWIGINTERNSHORT unsigned long
1717 SWIG_As_unsigned_SS_long(PyObject* obj)
1718 {
1719   unsigned long v;
1720   if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1721     /*
1722       this is needed to make valgrind/purify happier.
1723      */
1724     memset((void*)&v, 0, sizeof(unsigned long));
1725   }
1726   return v;
1727 }
1728
1729
1730 SWIGINTERNSHORT int
1731 SWIG_Check_unsigned_SS_long(PyObject* obj)
1732 {
1733   return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1734 }
1735
1736 static void wxTextCtrl_write(wxTextCtrl *self,wxString const &text){
1737             self->AppendText(text);
1738         }
1739 static wxString wxTextCtrl_GetString(wxTextCtrl *self,long from,long to){
1740             return self->GetValue().Mid(from, to - from);
1741         }
1742  static const wxString wxPyScrollBarNameStr(wxScrollBarNameStr);
1743  static const wxString wxPySPIN_BUTTON_NAME(wxSPIN_BUTTON_NAME);
1744  static const wxString wxPySpinCtrlNameStr(_T("wxSpinCtrl"));
1745  static const wxString wxPyRadioBoxNameStr(wxRadioBoxNameStr);
1746  static const wxString wxPyRadioButtonNameStr(wxRadioButtonNameStr);
1747
1748 #include <wx/slider.h>
1749
1750
1751  static const wxString wxPySliderNameStr(wxSliderNameStr);
1752  static const wxString wxPyToggleButtonNameStr(_T("wxToggleButton"));
1753
1754 #if !wxUSE_TOGGLEBTN
1755 // implement dummy items for platforms that don't have this class
1756
1757 #define wxEVT_COMMAND_TOGGLEBUTTON_CLICKED 0
1758
1759 class wxToggleButton : public wxControl
1760 {
1761 public:
1762     wxToggleButton(wxWindow *, wxWindowID, const wxString&,
1763                    const wxPoint&, const wxSize&, long,
1764                    const wxValidator&, const wxString&)
1765         { wxPyRaiseNotImplemented(); }
1766
1767     wxToggleButton()
1768         { wxPyRaiseNotImplemented(); }
1769 };
1770 #endif
1771
1772  static const wxString wxPyNOTEBOOK_NAME(wxNOTEBOOK_NAME);
1773
1774 SWIGINTERNSHORT PyObject*
1775   SWIG_From_unsigned_SS_long(unsigned long value)
1776 {
1777   return (value > LONG_MAX) ?
1778     PyLong_FromUnsignedLong(value)
1779     : PyInt_FromLong((long)(value));
1780 }
1781
1782  static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
1783 static PyObject *wxToolBarToolBase_GetClientData(wxToolBarToolBase *self){
1784             wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
1785             if (udata) {
1786                 Py_INCREF(udata->m_obj);
1787                 return udata->m_obj;
1788             } else {
1789                 Py_INCREF(Py_None);
1790                 return Py_None;
1791             }
1792         }
1793 static void wxToolBarToolBase_SetClientData(wxToolBarToolBase *self,PyObject *clientData){
1794             self->SetClientData(new wxPyUserData(clientData));
1795         }
1796 static wxToolBarToolBase *wxToolBarBase_DoAddTool(wxToolBarBase *self,int id,wxString const &label,wxBitmap const &bitmap,wxBitmap const &bmpDisabled=wxNullBitmap,wxItemKind kind=wxITEM_NORMAL,wxString const &shortHelp=wxPyEmptyString,wxString const &longHelp=wxPyEmptyString,PyObject *clientData=NULL){
1797             wxPyUserData* udata = NULL;
1798             if (clientData && clientData != Py_None)
1799                 udata = new wxPyUserData(clientData);
1800             return self->AddTool(id, label, bitmap, bmpDisabled, kind,
1801                                  shortHelp, longHelp, udata);
1802         }
1803 static wxToolBarToolBase *wxToolBarBase_DoInsertTool(wxToolBarBase *self,size_t pos,int id,wxString const &label,wxBitmap const &bitmap,wxBitmap const &bmpDisabled=wxNullBitmap,wxItemKind kind=wxITEM_NORMAL,wxString const &shortHelp=wxPyEmptyString,wxString const &longHelp=wxPyEmptyString,PyObject *clientData=NULL){
1804             wxPyUserData* udata = NULL;
1805             if (clientData && clientData != Py_None)
1806                 udata = new wxPyUserData(clientData);
1807             return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
1808                                     shortHelp, longHelp, udata);
1809         }
1810 static PyObject *wxToolBarBase_GetToolClientData(wxToolBarBase *self,int id){
1811             wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
1812             if (udata) {
1813                 Py_INCREF(udata->m_obj);
1814                 return udata->m_obj;
1815             } else {
1816                 Py_INCREF(Py_None);
1817                 return Py_None;
1818             }
1819         }
1820 static void wxToolBarBase_SetToolClientData(wxToolBarBase *self,int id,PyObject *clientData){
1821             self->SetToolClientData(id, new wxPyUserData(clientData));
1822         }
1823
1824 #include <wx/listctrl.h>
1825
1826  static const wxString wxPyListCtrlNameStr(_T("wxListCtrl"));
1827 static void wxListItemAttr_Destroy(wxListItemAttr *self){ delete self; }
1828  // Python aware sorting function for wxPyListCtrl
1829     static int wxCALLBACK wxPyListCtrl_SortItems(long item1, long item2, long funcPtr) {
1830         int retval = 0;
1831         PyObject* func = (PyObject*)funcPtr;
1832         bool blocked = wxPyBeginBlockThreads();
1833
1834         PyObject* args = Py_BuildValue("(ii)", item1, item2);
1835         PyObject* result = PyEval_CallObject(func, args);
1836         Py_DECREF(args);
1837         if (result) {
1838             retval = PyInt_AsLong(result);
1839             Py_DECREF(result);
1840         }
1841
1842         wxPyEndBlockThreads(blocked);
1843         return retval;
1844     }
1845
1846   // C++ Version of a Python aware class
1847 class wxPyListCtrl : public wxListCtrl {
1848     DECLARE_ABSTRACT_CLASS(wxPyListCtrl);
1849 public:
1850     wxPyListCtrl() : wxListCtrl() {}
1851     wxPyListCtrl(wxWindow* parent, wxWindowID id,
1852                  const wxPoint& pos,
1853                  const wxSize& size,
1854                  long style,
1855                  const wxValidator& validator,
1856                  const wxString& name) :
1857         wxListCtrl(parent, id, pos, size, style, validator, name) {}
1858
1859     bool Create(wxWindow* parent, wxWindowID id,
1860                 const wxPoint& pos,
1861                 const wxSize& size,
1862                 long style,
1863                 const wxValidator& validator,
1864                 const wxString& name) {
1865         return wxListCtrl::Create(parent, id, pos, size, style, validator, name);
1866     }
1867
1868     DEC_PYCALLBACK_STRING_LONGLONG(OnGetItemText);
1869     DEC_PYCALLBACK_LISTATTR_LONG(OnGetItemAttr);
1870
1871     // use the virtual version to avoid a confusing assert in the base class
1872     DEC_PYCALLBACK_INT_LONG_virtual(OnGetItemImage);
1873
1874     PYPRIVATE;
1875 };
1876
1877 IMPLEMENT_ABSTRACT_CLASS(wxPyListCtrl, wxListCtrl);
1878
1879 IMP_PYCALLBACK_STRING_LONGLONG(wxPyListCtrl, wxListCtrl, OnGetItemText);
1880 IMP_PYCALLBACK_LISTATTR_LONG(wxPyListCtrl, wxListCtrl, OnGetItemAttr);
1881 IMP_PYCALLBACK_INT_LONG_virtual(wxPyListCtrl, wxListCtrl, OnGetItemImage);
1882
1883
1884 static wxListItem *wxPyListCtrl_GetColumn(wxPyListCtrl *self,int col){
1885             wxListItem item;
1886             item.SetMask( wxLIST_MASK_STATE |
1887                           wxLIST_MASK_TEXT  |
1888                           wxLIST_MASK_IMAGE |
1889                           wxLIST_MASK_DATA  |
1890                           wxLIST_SET_ITEM   |
1891                           wxLIST_MASK_WIDTH |
1892                           wxLIST_MASK_FORMAT
1893                           );
1894             if (self->GetColumn(col, item))
1895                 return new wxListItem(item);
1896             else
1897                 return NULL;
1898         }
1899 static wxListItem *wxPyListCtrl_GetItem(wxPyListCtrl *self,long itemId,int col=0){
1900             wxListItem* info = new wxListItem;
1901             info->m_itemId = itemId;
1902             info->m_col = col;
1903             info->m_mask = 0xFFFF;
1904             self->GetItem(*info);
1905             return info;
1906         }
1907 static wxPoint wxPyListCtrl_GetItemPosition(wxPyListCtrl *self,long item){
1908             wxPoint pos;
1909             self->GetItemPosition(item, pos);
1910             return pos;
1911         }
1912 static wxRect wxPyListCtrl_GetItemRect(wxPyListCtrl *self,long item,int code=wxLIST_RECT_BOUNDS){
1913             wxRect rect;
1914             self->GetItemRect(item, rect, code);
1915             return rect;
1916         }
1917
1918 static bool wxPyListCtrl_SortItems(wxPyListCtrl *self,PyObject *func){
1919             if (!PyCallable_Check(func))
1920                 return false;
1921             return self->SortItems((wxListCtrlCompare)wxPyListCtrl_SortItems, (long)func);
1922         }
1923 static wxWindow *wxPyListCtrl_GetMainWindow(wxPyListCtrl *self){
1924
1925             return self;
1926
1927
1928
1929         }
1930
1931 #include <wx/treectrl.h>
1932 #include "wx/wxPython/pytree.h"
1933
1934  static const wxString wxPyTreeCtrlNameStr(_T("wxTreeCtrl"));
1935 static bool wxTreeItemId___eq__(wxTreeItemId *self,wxTreeItemId const *other){ return other ? (*self == *other) : false; }
1936 static bool wxTreeItemId___ne__(wxTreeItemId *self,wxTreeItemId const *other){ return other ? (*self != *other) : true;  }
1937 static void wxPyTreeItemData_Destroy(wxPyTreeItemData *self){ delete self; }
1938  // C++ version of Python aware wxTreeCtrl
1939 class wxPyTreeCtrl : public wxTreeCtrl {
1940     DECLARE_ABSTRACT_CLASS(wxPyTreeCtrl);
1941 public:
1942     wxPyTreeCtrl() : wxTreeCtrl() {}
1943     wxPyTreeCtrl(wxWindow *parent, wxWindowID id,
1944                  const wxPoint& pos,
1945                  const wxSize& size,
1946                  long style,
1947                  const wxValidator& validator,
1948                  const wxString& name) :
1949         wxTreeCtrl(parent, id, pos, size, style, validator, name) {}
1950
1951     bool Create(wxWindow *parent, wxWindowID id,
1952                 const wxPoint& pos,
1953                 const wxSize& size,
1954                 long style,
1955                 const wxValidator& validator,
1956                 const wxString& name) {
1957         return wxTreeCtrl::Create(parent, id, pos, size, style, validator, name);
1958     }
1959
1960
1961     int OnCompareItems(const wxTreeItemId& item1,
1962                        const wxTreeItemId& item2) {
1963         int rval = 0;
1964         bool found;
1965         bool blocked = wxPyBeginBlockThreads();
1966         if ((found = wxPyCBH_findCallback(m_myInst, "OnCompareItems"))) {
1967             PyObject *o1 = wxPyConstructObject((void*)&item1, wxT("wxTreeItemId"), false);
1968             PyObject *o2 = wxPyConstructObject((void*)&item2, wxT("wxTreeItemId"), false);
1969             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",o1,o2));
1970             Py_DECREF(o1);
1971             Py_DECREF(o2);
1972         }
1973         wxPyEndBlockThreads(blocked);
1974         if (! found)
1975             rval = wxTreeCtrl::OnCompareItems(item1, item2);
1976         return rval;
1977     }
1978     PYPRIVATE;
1979 };
1980
1981 IMPLEMENT_ABSTRACT_CLASS(wxPyTreeCtrl, wxTreeCtrl);
1982
1983
1984
1985 #if UINT_MAX < LONG_MAX
1986 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1987 #define SWIG_From_unsigned_SS_int SWIG_From_long
1988 /*@@*/
1989 #else
1990 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1991 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
1992 /*@@*/
1993 #endif
1994
1995
1996 SWIGINTERNSHORT int
1997   SWIG_CheckUnsignedLongInRange(unsigned long value,
1998                                 unsigned long max_value,
1999                                 const char *errmsg)
2000 {
2001   if (value > max_value) {
2002     if (errmsg) {
2003       PyErr_Format(PyExc_OverflowError,
2004                    "value %lu is greater than '%s' minimum %lu",
2005                    value, errmsg, max_value);
2006     }
2007     return 0;
2008   }
2009   return 1;
2010  }
2011
2012
2013 #if UINT_MAX != ULONG_MAX
2014 SWIGINTERN int
2015   SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2016 {
2017   const char* errmsg = val ? "unsigned int" : (char*)0;
2018   unsigned long v;
2019   if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2020     if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2021       if (val) *val = (unsigned int)(v);
2022       return 1;
2023     }
2024   } else {
2025     PyErr_Clear();
2026   }
2027   if (val) {
2028     SWIG_type_error(errmsg, obj);
2029   }
2030   return 0;
2031 }
2032 #else
2033 SWIGINTERNSHORT unsigned int
2034   SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2035 {
2036   return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2037 }
2038 #endif
2039
2040
2041 SWIGINTERNSHORT unsigned int
2042 SWIG_As_unsigned_SS_int(PyObject* obj)
2043 {
2044   unsigned int v;
2045   if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2046     /*
2047       this is needed to make valgrind/purify happier.
2048      */
2049     memset((void*)&v, 0, sizeof(unsigned int));
2050   }
2051   return v;
2052 }
2053
2054
2055 SWIGINTERNSHORT int
2056 SWIG_Check_unsigned_SS_int(PyObject* obj)
2057 {
2058   return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2059 }
2060
2061 static wxPyTreeItemData *wxPyTreeCtrl_GetItemData(wxPyTreeCtrl *self,wxTreeItemId const &item){
2062             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
2063             if (data == NULL) {
2064                 data = new wxPyTreeItemData();
2065                 data->SetId(item); // set the id
2066                 self->SetItemData(item, data);
2067             }
2068             return data;
2069         }
2070 static PyObject *wxPyTreeCtrl_GetItemPyData(wxPyTreeCtrl *self,wxTreeItemId const &item){
2071             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
2072             if (data == NULL) {
2073                 data = new wxPyTreeItemData();
2074                 data->SetId(item); // set the id
2075                 self->SetItemData(item, data);
2076             }
2077             return data->GetData();
2078         }
2079 static void wxPyTreeCtrl_SetItemData(wxPyTreeCtrl *self,wxTreeItemId const &item,wxPyTreeItemData *data){
2080             data->SetId(item); // set the id
2081             self->SetItemData(item, data);
2082         }
2083 static void wxPyTreeCtrl_SetItemPyData(wxPyTreeCtrl *self,wxTreeItemId const &item,PyObject *obj){
2084             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
2085             if (data == NULL) {
2086                 data = new wxPyTreeItemData(obj);
2087                 data->SetId(item); // set the id
2088                 self->SetItemData(item, data);
2089             } else
2090                 data->SetData(obj);
2091         }
2092 static PyObject *wxPyTreeCtrl_GetSelections(wxPyTreeCtrl *self){
2093             bool blocked = wxPyBeginBlockThreads();
2094             PyObject*           rval = PyList_New(0);
2095             wxArrayTreeItemIds  array;
2096             size_t              num, x;
2097             num = self->GetSelections(array);
2098             for (x=0; x < num; x++) {
2099                 wxTreeItemId *tii = new wxTreeItemId(array.Item(x));
2100                 PyObject* item = wxPyConstructObject((void*)tii, wxT("wxTreeItemId"), true);
2101                 PyList_Append(rval, item);
2102                 Py_DECREF(item);
2103             }
2104             wxPyEndBlockThreads(blocked);
2105             return rval;
2106         }
2107 static PyObject *wxPyTreeCtrl_GetFirstChild(wxPyTreeCtrl *self,wxTreeItemId const &item){
2108             void* cookie = 0;
2109             wxTreeItemId* ritem = new wxTreeItemId(self->GetFirstChild(item, cookie));
2110             bool blocked = wxPyBeginBlockThreads();
2111             PyObject* tup = PyTuple_New(2);
2112             PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
2113             PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
2114             wxPyEndBlockThreads(blocked);
2115             return tup;
2116         }
2117 static PyObject *wxPyTreeCtrl_GetNextChild(wxPyTreeCtrl *self,wxTreeItemId const &item,void *cookie){
2118             wxTreeItemId* ritem = new wxTreeItemId(self->GetNextChild(item, cookie));
2119             bool blocked = wxPyBeginBlockThreads();
2120             PyObject* tup = PyTuple_New(2);
2121             PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
2122             PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
2123             wxPyEndBlockThreads(blocked);
2124             return tup;
2125         }
2126 static PyObject *wxPyTreeCtrl_GetBoundingRect(wxPyTreeCtrl *self,wxTreeItemId const &item,bool textOnly=false){
2127              wxRect rect;
2128             if (self->GetBoundingRect(item, rect, textOnly)) {
2129                 bool blocked = wxPyBeginBlockThreads();
2130                 wxRect* r = new wxRect(rect);
2131                 PyObject* val = wxPyConstructObject((void*)r, wxT("wxRect"), true);
2132                 wxPyEndBlockThreads(blocked);
2133                 return val;
2134             }
2135             else
2136                 RETURN_NONE();
2137         }
2138  static const wxString wxPyDirDialogDefaultFolderStr(wxDirDialogDefaultFolderStr);
2139
2140 SWIGINTERNSHORT PyObject*
2141   SWIG_From_bool(bool value)
2142 {
2143   PyObject *obj = value ? Py_True : Py_False;
2144   Py_INCREF(obj);
2145   return obj;
2146 }
2147
2148
2149  // C++ version of Python aware wxControl
2150 class wxPyControl : public wxControl
2151 {
2152     DECLARE_DYNAMIC_CLASS(wxPyControl)
2153 public:
2154     wxPyControl() : wxControl() {}
2155     wxPyControl(wxWindow* parent, const wxWindowID id,
2156                 const wxPoint& pos = wxDefaultPosition,
2157                 const wxSize& size = wxDefaultSize,
2158                 long style = 0,
2159                 const wxValidator& validator=wxDefaultValidator,
2160                 const wxString& name = wxPyControlNameStr)
2161         : wxControl(parent, id, pos, size, style, validator, name) {}
2162
2163     void SetBestSize(const wxSize& size) { wxControl::SetBestSize(size); }
2164
2165     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2166     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2167     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2168     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2169
2170     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2171     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2172     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2173
2174     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2175     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2176
2177     DEC_PYCALLBACK__(InitDialog);
2178     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2179     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2180     DEC_PYCALLBACK_BOOL_(Validate);
2181
2182     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2183     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2184     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2185
2186     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2187     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2188
2189     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2190     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2191     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2192
2193     PYPRIVATE;
2194 };
2195
2196 IMPLEMENT_DYNAMIC_CLASS(wxPyControl, wxControl);
2197
2198 IMP_PYCALLBACK_VOID_INT4(wxPyControl, wxControl, DoMoveWindow);
2199 IMP_PYCALLBACK_VOID_INT5(wxPyControl, wxControl, DoSetSize);
2200 IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetClientSize);
2201 IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetVirtualSize);
2202
2203 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetSize);
2204 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetClientSize);
2205 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetPosition);
2206
2207 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetVirtualSize);
2208 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetBestSize);
2209
2210 IMP_PYCALLBACK__(wxPyControl, wxControl, InitDialog);
2211 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataFromWindow);
2212 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataToWindow);
2213 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, Validate);
2214
2215 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocus);
2216 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocusFromKeyboard);
2217 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, GetMaxSize);
2218
2219 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, AddChild);
2220 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, RemoveChild);
2221
2222 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, ShouldInheritColours);
2223 IMP_PYCALLBACK__COLOUR(wxPyControl, wxControl, ApplyParentThemeBackground);
2224 IMP_PYCALLBACK_VIZATTR_(wxPyControl, wxControl, GetDefaultAttributes);
2225
2226
2227
2228 static void wxHelpProvider_Destroy(wxHelpProvider *self){ delete self; }
2229
2230 #include <wx/generic/dragimgg.h>
2231
2232 #ifdef __cplusplus
2233 extern "C" {
2234 #endif
2235 static int _wrap_ButtonNameStr_set(PyObject *) {
2236     PyErr_SetString(PyExc_TypeError,"Variable ButtonNameStr is read-only.");
2237     return 1;
2238 }
2239
2240
2241 static PyObject *_wrap_ButtonNameStr_get(void) {
2242     PyObject *pyobj;
2243
2244     {
2245 #if wxUSE_UNICODE
2246         pyobj = PyUnicode_FromWideChar((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
2247 #else
2248         pyobj = PyString_FromStringAndSize((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
2249 #endif
2250     }
2251     return pyobj;
2252 }
2253
2254
2255 static PyObject *_wrap_new_Button(PyObject *, PyObject *args, PyObject *kwargs) {
2256     PyObject *resultobj;
2257     wxWindow *arg1 = (wxWindow *) 0 ;
2258     int arg2 = (int) -1 ;
2259     wxString const &arg3_defvalue = wxPyEmptyString ;
2260     wxString *arg3 = (wxString *) &arg3_defvalue ;
2261     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2262     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2263     wxSize const &arg5_defvalue = wxDefaultSize ;
2264     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2265     long arg6 = (long) 0 ;
2266     wxValidator const &arg7_defvalue = wxDefaultValidator ;
2267     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
2268     wxString const &arg8_defvalue = wxPyButtonNameStr ;
2269     wxString *arg8 = (wxString *) &arg8_defvalue ;
2270     wxButton *result;
2271     bool temp3 = false ;
2272     wxPoint temp4 ;
2273     wxSize temp5 ;
2274     bool temp8 = false ;
2275     PyObject * obj0 = 0 ;
2276     PyObject * obj1 = 0 ;
2277     PyObject * obj2 = 0 ;
2278     PyObject * obj3 = 0 ;
2279     PyObject * obj4 = 0 ;
2280     PyObject * obj5 = 0 ;
2281     PyObject * obj6 = 0 ;
2282     PyObject * obj7 = 0 ;
2283     char *kwnames[] = {
2284         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2285     };
2286
2287     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Button",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2288     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2289     if (SWIG_arg_fail(1)) SWIG_fail;
2290     if (obj1) {
2291         {
2292             arg2 = (int)(SWIG_As_int(obj1));
2293             if (SWIG_arg_fail(2)) SWIG_fail;
2294         }
2295     }
2296     if (obj2) {
2297         {
2298             arg3 = wxString_in_helper(obj2);
2299             if (arg3 == NULL) SWIG_fail;
2300             temp3 = true;
2301         }
2302     }
2303     if (obj3) {
2304         {
2305             arg4 = &temp4;
2306             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2307         }
2308     }
2309     if (obj4) {
2310         {
2311             arg5 = &temp5;
2312             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2313         }
2314     }
2315     if (obj5) {
2316         {
2317             arg6 = (long)(SWIG_As_long(obj5));
2318             if (SWIG_arg_fail(6)) SWIG_fail;
2319         }
2320     }
2321     if (obj6) {
2322         {
2323             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2324             if (SWIG_arg_fail(7)) SWIG_fail;
2325             if (arg7 == NULL) {
2326                 SWIG_null_ref("wxValidator");
2327             }
2328             if (SWIG_arg_fail(7)) SWIG_fail;
2329         }
2330     }
2331     if (obj7) {
2332         {
2333             arg8 = wxString_in_helper(obj7);
2334             if (arg8 == NULL) SWIG_fail;
2335             temp8 = true;
2336         }
2337     }
2338     {
2339         if (!wxPyCheckForApp()) SWIG_fail;
2340         PyThreadState* __tstate = wxPyBeginAllowThreads();
2341         result = (wxButton *)new wxButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
2342
2343         wxPyEndAllowThreads(__tstate);
2344         if (PyErr_Occurred()) SWIG_fail;
2345     }
2346     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxButton, 1);
2347     {
2348         if (temp3)
2349         delete arg3;
2350     }
2351     {
2352         if (temp8)
2353         delete arg8;
2354     }
2355     return resultobj;
2356     fail:
2357     {
2358         if (temp3)
2359         delete arg3;
2360     }
2361     {
2362         if (temp8)
2363         delete arg8;
2364     }
2365     return NULL;
2366 }
2367
2368
2369 static PyObject *_wrap_new_PreButton(PyObject *, PyObject *args, PyObject *kwargs) {
2370     PyObject *resultobj;
2371     wxButton *result;
2372     char *kwnames[] = {
2373         NULL
2374     };
2375
2376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreButton",kwnames)) goto fail;
2377     {
2378         if (!wxPyCheckForApp()) SWIG_fail;
2379         PyThreadState* __tstate = wxPyBeginAllowThreads();
2380         result = (wxButton *)new wxButton();
2381
2382         wxPyEndAllowThreads(__tstate);
2383         if (PyErr_Occurred()) SWIG_fail;
2384     }
2385     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxButton, 1);
2386     return resultobj;
2387     fail:
2388     return NULL;
2389 }
2390
2391
2392 static PyObject *_wrap_Button_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2393     PyObject *resultobj;
2394     wxButton *arg1 = (wxButton *) 0 ;
2395     wxWindow *arg2 = (wxWindow *) 0 ;
2396     int arg3 = (int) -1 ;
2397     wxString const &arg4_defvalue = wxPyEmptyString ;
2398     wxString *arg4 = (wxString *) &arg4_defvalue ;
2399     wxPoint const &arg5_defvalue = wxDefaultPosition ;
2400     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
2401     wxSize const &arg6_defvalue = wxDefaultSize ;
2402     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
2403     long arg7 = (long) 0 ;
2404     wxValidator const &arg8_defvalue = wxDefaultValidator ;
2405     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
2406     wxString const &arg9_defvalue = wxPyButtonNameStr ;
2407     wxString *arg9 = (wxString *) &arg9_defvalue ;
2408     bool result;
2409     bool temp4 = false ;
2410     wxPoint temp5 ;
2411     wxSize temp6 ;
2412     bool temp9 = false ;
2413     PyObject * obj0 = 0 ;
2414     PyObject * obj1 = 0 ;
2415     PyObject * obj2 = 0 ;
2416     PyObject * obj3 = 0 ;
2417     PyObject * obj4 = 0 ;
2418     PyObject * obj5 = 0 ;
2419     PyObject * obj6 = 0 ;
2420     PyObject * obj7 = 0 ;
2421     PyObject * obj8 = 0 ;
2422     char *kwnames[] = {
2423         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2424     };
2425
2426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Button_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
2428     if (SWIG_arg_fail(1)) SWIG_fail;
2429     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2430     if (SWIG_arg_fail(2)) SWIG_fail;
2431     if (obj2) {
2432         {
2433             arg3 = (int)(SWIG_As_int(obj2));
2434             if (SWIG_arg_fail(3)) SWIG_fail;
2435         }
2436     }
2437     if (obj3) {
2438         {
2439             arg4 = wxString_in_helper(obj3);
2440             if (arg4 == NULL) SWIG_fail;
2441             temp4 = true;
2442         }
2443     }
2444     if (obj4) {
2445         {
2446             arg5 = &temp5;
2447             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
2448         }
2449     }
2450     if (obj5) {
2451         {
2452             arg6 = &temp6;
2453             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
2454         }
2455     }
2456     if (obj6) {
2457         {
2458             arg7 = (long)(SWIG_As_long(obj6));
2459             if (SWIG_arg_fail(7)) SWIG_fail;
2460         }
2461     }
2462     if (obj7) {
2463         {
2464             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2465             if (SWIG_arg_fail(8)) SWIG_fail;
2466             if (arg8 == NULL) {
2467                 SWIG_null_ref("wxValidator");
2468             }
2469             if (SWIG_arg_fail(8)) SWIG_fail;
2470         }
2471     }
2472     if (obj8) {
2473         {
2474             arg9 = wxString_in_helper(obj8);
2475             if (arg9 == NULL) SWIG_fail;
2476             temp9 = true;
2477         }
2478     }
2479     {
2480         PyThreadState* __tstate = wxPyBeginAllowThreads();
2481         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
2482
2483         wxPyEndAllowThreads(__tstate);
2484         if (PyErr_Occurred()) SWIG_fail;
2485     }
2486     {
2487         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2488     }
2489     {
2490         if (temp4)
2491         delete arg4;
2492     }
2493     {
2494         if (temp9)
2495         delete arg9;
2496     }
2497     return resultobj;
2498     fail:
2499     {
2500         if (temp4)
2501         delete arg4;
2502     }
2503     {
2504         if (temp9)
2505         delete arg9;
2506     }
2507     return NULL;
2508 }
2509
2510
2511 static PyObject *_wrap_Button_SetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
2512     PyObject *resultobj;
2513     wxButton *arg1 = (wxButton *) 0 ;
2514     PyObject * obj0 = 0 ;
2515     char *kwnames[] = {
2516         (char *) "self", NULL
2517     };
2518
2519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Button_SetDefault",kwnames,&obj0)) goto fail;
2520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
2521     if (SWIG_arg_fail(1)) SWIG_fail;
2522     {
2523         PyThreadState* __tstate = wxPyBeginAllowThreads();
2524         (arg1)->SetDefault();
2525
2526         wxPyEndAllowThreads(__tstate);
2527         if (PyErr_Occurred()) SWIG_fail;
2528     }
2529     Py_INCREF(Py_None); resultobj = Py_None;
2530     return resultobj;
2531     fail:
2532     return NULL;
2533 }
2534
2535
2536 static PyObject *_wrap_Button_GetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
2537     PyObject *resultobj;
2538     wxSize result;
2539     char *kwnames[] = {
2540         NULL
2541     };
2542
2543     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Button_GetDefaultSize",kwnames)) goto fail;
2544     {
2545         PyThreadState* __tstate = wxPyBeginAllowThreads();
2546         result = wxButton::GetDefaultSize();
2547
2548         wxPyEndAllowThreads(__tstate);
2549         if (PyErr_Occurred()) SWIG_fail;
2550     }
2551     {
2552         wxSize * resultptr;
2553         resultptr = new wxSize((wxSize &)(result));
2554         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2555     }
2556     return resultobj;
2557     fail:
2558     return NULL;
2559 }
2560
2561
2562 static PyObject *_wrap_Button_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
2563     PyObject *resultobj;
2564     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
2565     wxVisualAttributes result;
2566     PyObject * obj0 = 0 ;
2567     char *kwnames[] = {
2568         (char *) "variant", NULL
2569     };
2570
2571     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Button_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
2572     if (obj0) {
2573         {
2574             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
2575             if (SWIG_arg_fail(1)) SWIG_fail;
2576         }
2577     }
2578     {
2579         if (!wxPyCheckForApp()) SWIG_fail;
2580         PyThreadState* __tstate = wxPyBeginAllowThreads();
2581         result = wxButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
2582
2583         wxPyEndAllowThreads(__tstate);
2584         if (PyErr_Occurred()) SWIG_fail;
2585     }
2586     {
2587         wxVisualAttributes * resultptr;
2588         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
2589         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
2590     }
2591     return resultobj;
2592     fail:
2593     return NULL;
2594 }
2595
2596
2597 static PyObject * Button_swigregister(PyObject *, PyObject *args) {
2598     PyObject *obj;
2599     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2600     SWIG_TypeClientData(SWIGTYPE_p_wxButton, obj);
2601     Py_INCREF(obj);
2602     return Py_BuildValue((char *)"");
2603 }
2604 static PyObject *_wrap_new_BitmapButton(PyObject *, PyObject *args, PyObject *kwargs) {
2605     PyObject *resultobj;
2606     wxWindow *arg1 = (wxWindow *) 0 ;
2607     int arg2 = (int) -1 ;
2608     wxBitmap const &arg3_defvalue = wxNullBitmap ;
2609     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
2610     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2611     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2612     wxSize const &arg5_defvalue = wxDefaultSize ;
2613     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2614     long arg6 = (long) wxBU_AUTODRAW ;
2615     wxValidator const &arg7_defvalue = wxDefaultValidator ;
2616     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
2617     wxString const &arg8_defvalue = wxPyButtonNameStr ;
2618     wxString *arg8 = (wxString *) &arg8_defvalue ;
2619     wxBitmapButton *result;
2620     wxPoint temp4 ;
2621     wxSize temp5 ;
2622     bool temp8 = false ;
2623     PyObject * obj0 = 0 ;
2624     PyObject * obj1 = 0 ;
2625     PyObject * obj2 = 0 ;
2626     PyObject * obj3 = 0 ;
2627     PyObject * obj4 = 0 ;
2628     PyObject * obj5 = 0 ;
2629     PyObject * obj6 = 0 ;
2630     PyObject * obj7 = 0 ;
2631     char *kwnames[] = {
2632         (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2633     };
2634
2635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_BitmapButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2637     if (SWIG_arg_fail(1)) SWIG_fail;
2638     if (obj1) {
2639         {
2640             arg2 = (int)(SWIG_As_int(obj1));
2641             if (SWIG_arg_fail(2)) SWIG_fail;
2642         }
2643     }
2644     if (obj2) {
2645         {
2646             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2647             if (SWIG_arg_fail(3)) SWIG_fail;
2648             if (arg3 == NULL) {
2649                 SWIG_null_ref("wxBitmap");
2650             }
2651             if (SWIG_arg_fail(3)) SWIG_fail;
2652         }
2653     }
2654     if (obj3) {
2655         {
2656             arg4 = &temp4;
2657             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2658         }
2659     }
2660     if (obj4) {
2661         {
2662             arg5 = &temp5;
2663             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2664         }
2665     }
2666     if (obj5) {
2667         {
2668             arg6 = (long)(SWIG_As_long(obj5));
2669             if (SWIG_arg_fail(6)) SWIG_fail;
2670         }
2671     }
2672     if (obj6) {
2673         {
2674             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2675             if (SWIG_arg_fail(7)) SWIG_fail;
2676             if (arg7 == NULL) {
2677                 SWIG_null_ref("wxValidator");
2678             }
2679             if (SWIG_arg_fail(7)) SWIG_fail;
2680         }
2681     }
2682     if (obj7) {
2683         {
2684             arg8 = wxString_in_helper(obj7);
2685             if (arg8 == NULL) SWIG_fail;
2686             temp8 = true;
2687         }
2688     }
2689     {
2690         if (!wxPyCheckForApp()) SWIG_fail;
2691         PyThreadState* __tstate = wxPyBeginAllowThreads();
2692         result = (wxBitmapButton *)new wxBitmapButton(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
2693
2694         wxPyEndAllowThreads(__tstate);
2695         if (PyErr_Occurred()) SWIG_fail;
2696     }
2697     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapButton, 1);
2698     {
2699         if (temp8)
2700         delete arg8;
2701     }
2702     return resultobj;
2703     fail:
2704     {
2705         if (temp8)
2706         delete arg8;
2707     }
2708     return NULL;
2709 }
2710
2711
2712 static PyObject *_wrap_new_PreBitmapButton(PyObject *, PyObject *args, PyObject *kwargs) {
2713     PyObject *resultobj;
2714     wxBitmapButton *result;
2715     char *kwnames[] = {
2716         NULL
2717     };
2718
2719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreBitmapButton",kwnames)) goto fail;
2720     {
2721         if (!wxPyCheckForApp()) SWIG_fail;
2722         PyThreadState* __tstate = wxPyBeginAllowThreads();
2723         result = (wxBitmapButton *)new wxBitmapButton();
2724
2725         wxPyEndAllowThreads(__tstate);
2726         if (PyErr_Occurred()) SWIG_fail;
2727     }
2728     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapButton, 1);
2729     return resultobj;
2730     fail:
2731     return NULL;
2732 }
2733
2734
2735 static PyObject *_wrap_BitmapButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2736     PyObject *resultobj;
2737     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2738     wxWindow *arg2 = (wxWindow *) 0 ;
2739     int arg3 = (int) -1 ;
2740     wxBitmap const &arg4_defvalue = wxNullBitmap ;
2741     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
2742     wxPoint const &arg5_defvalue = wxDefaultPosition ;
2743     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
2744     wxSize const &arg6_defvalue = wxDefaultSize ;
2745     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
2746     long arg7 = (long) wxBU_AUTODRAW ;
2747     wxValidator const &arg8_defvalue = wxDefaultValidator ;
2748     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
2749     wxString const &arg9_defvalue = wxPyButtonNameStr ;
2750     wxString *arg9 = (wxString *) &arg9_defvalue ;
2751     bool result;
2752     wxPoint temp5 ;
2753     wxSize temp6 ;
2754     bool temp9 = false ;
2755     PyObject * obj0 = 0 ;
2756     PyObject * obj1 = 0 ;
2757     PyObject * obj2 = 0 ;
2758     PyObject * obj3 = 0 ;
2759     PyObject * obj4 = 0 ;
2760     PyObject * obj5 = 0 ;
2761     PyObject * obj6 = 0 ;
2762     PyObject * obj7 = 0 ;
2763     PyObject * obj8 = 0 ;
2764     char *kwnames[] = {
2765         (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2766     };
2767
2768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:BitmapButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2770     if (SWIG_arg_fail(1)) SWIG_fail;
2771     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2772     if (SWIG_arg_fail(2)) SWIG_fail;
2773     if (obj2) {
2774         {
2775             arg3 = (int)(SWIG_As_int(obj2));
2776             if (SWIG_arg_fail(3)) SWIG_fail;
2777         }
2778     }
2779     if (obj3) {
2780         {
2781             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2782             if (SWIG_arg_fail(4)) SWIG_fail;
2783             if (arg4 == NULL) {
2784                 SWIG_null_ref("wxBitmap");
2785             }
2786             if (SWIG_arg_fail(4)) SWIG_fail;
2787         }
2788     }
2789     if (obj4) {
2790         {
2791             arg5 = &temp5;
2792             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
2793         }
2794     }
2795     if (obj5) {
2796         {
2797             arg6 = &temp6;
2798             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
2799         }
2800     }
2801     if (obj6) {
2802         {
2803             arg7 = (long)(SWIG_As_long(obj6));
2804             if (SWIG_arg_fail(7)) SWIG_fail;
2805         }
2806     }
2807     if (obj7) {
2808         {
2809             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2810             if (SWIG_arg_fail(8)) SWIG_fail;
2811             if (arg8 == NULL) {
2812                 SWIG_null_ref("wxValidator");
2813             }
2814             if (SWIG_arg_fail(8)) SWIG_fail;
2815         }
2816     }
2817     if (obj8) {
2818         {
2819             arg9 = wxString_in_helper(obj8);
2820             if (arg9 == NULL) SWIG_fail;
2821             temp9 = true;
2822         }
2823     }
2824     {
2825         PyThreadState* __tstate = wxPyBeginAllowThreads();
2826         result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
2827
2828         wxPyEndAllowThreads(__tstate);
2829         if (PyErr_Occurred()) SWIG_fail;
2830     }
2831     {
2832         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2833     }
2834     {
2835         if (temp9)
2836         delete arg9;
2837     }
2838     return resultobj;
2839     fail:
2840     {
2841         if (temp9)
2842         delete arg9;
2843     }
2844     return NULL;
2845 }
2846
2847
2848 static PyObject *_wrap_BitmapButton_GetBitmapLabel(PyObject *, PyObject *args, PyObject *kwargs) {
2849     PyObject *resultobj;
2850     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2851     wxBitmap result;
2852     PyObject * obj0 = 0 ;
2853     char *kwnames[] = {
2854         (char *) "self", NULL
2855     };
2856
2857     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapLabel",kwnames,&obj0)) goto fail;
2858     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2859     if (SWIG_arg_fail(1)) SWIG_fail;
2860     {
2861         PyThreadState* __tstate = wxPyBeginAllowThreads();
2862         result = (arg1)->GetBitmapLabel();
2863
2864         wxPyEndAllowThreads(__tstate);
2865         if (PyErr_Occurred()) SWIG_fail;
2866     }
2867     {
2868         wxBitmap * resultptr;
2869         resultptr = new wxBitmap((wxBitmap &)(result));
2870         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2871     }
2872     return resultobj;
2873     fail:
2874     return NULL;
2875 }
2876
2877
2878 static PyObject *_wrap_BitmapButton_GetBitmapDisabled(PyObject *, PyObject *args, PyObject *kwargs) {
2879     PyObject *resultobj;
2880     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2881     wxBitmap result;
2882     PyObject * obj0 = 0 ;
2883     char *kwnames[] = {
2884         (char *) "self", NULL
2885     };
2886
2887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapDisabled",kwnames,&obj0)) goto fail;
2888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2889     if (SWIG_arg_fail(1)) SWIG_fail;
2890     {
2891         PyThreadState* __tstate = wxPyBeginAllowThreads();
2892         result = (arg1)->GetBitmapDisabled();
2893
2894         wxPyEndAllowThreads(__tstate);
2895         if (PyErr_Occurred()) SWIG_fail;
2896     }
2897     {
2898         wxBitmap * resultptr;
2899         resultptr = new wxBitmap((wxBitmap &)(result));
2900         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2901     }
2902     return resultobj;
2903     fail:
2904     return NULL;
2905 }
2906
2907
2908 static PyObject *_wrap_BitmapButton_GetBitmapFocus(PyObject *, PyObject *args, PyObject *kwargs) {
2909     PyObject *resultobj;
2910     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2911     wxBitmap result;
2912     PyObject * obj0 = 0 ;
2913     char *kwnames[] = {
2914         (char *) "self", NULL
2915     };
2916
2917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapFocus",kwnames,&obj0)) goto fail;
2918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2919     if (SWIG_arg_fail(1)) SWIG_fail;
2920     {
2921         PyThreadState* __tstate = wxPyBeginAllowThreads();
2922         result = (arg1)->GetBitmapFocus();
2923
2924         wxPyEndAllowThreads(__tstate);
2925         if (PyErr_Occurred()) SWIG_fail;
2926     }
2927     {
2928         wxBitmap * resultptr;
2929         resultptr = new wxBitmap((wxBitmap &)(result));
2930         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2931     }
2932     return resultobj;
2933     fail:
2934     return NULL;
2935 }
2936
2937
2938 static PyObject *_wrap_BitmapButton_GetBitmapSelected(PyObject *, PyObject *args, PyObject *kwargs) {
2939     PyObject *resultobj;
2940     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2941     wxBitmap result;
2942     PyObject * obj0 = 0 ;
2943     char *kwnames[] = {
2944         (char *) "self", NULL
2945     };
2946
2947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapSelected",kwnames,&obj0)) goto fail;
2948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2949     if (SWIG_arg_fail(1)) SWIG_fail;
2950     {
2951         PyThreadState* __tstate = wxPyBeginAllowThreads();
2952         result = (arg1)->GetBitmapSelected();
2953
2954         wxPyEndAllowThreads(__tstate);
2955         if (PyErr_Occurred()) SWIG_fail;
2956     }
2957     {
2958         wxBitmap * resultptr;
2959         resultptr = new wxBitmap((wxBitmap &)(result));
2960         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2961     }
2962     return resultobj;
2963     fail:
2964     return NULL;
2965 }
2966
2967
2968 static PyObject *_wrap_BitmapButton_SetBitmapDisabled(PyObject *, PyObject *args, PyObject *kwargs) {
2969     PyObject *resultobj;
2970     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2971     wxBitmap *arg2 = 0 ;
2972     PyObject * obj0 = 0 ;
2973     PyObject * obj1 = 0 ;
2974     char *kwnames[] = {
2975         (char *) "self",(char *) "bitmap", NULL
2976     };
2977
2978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapDisabled",kwnames,&obj0,&obj1)) goto fail;
2979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2980     if (SWIG_arg_fail(1)) SWIG_fail;
2981     {
2982         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2983         if (SWIG_arg_fail(2)) SWIG_fail;
2984         if (arg2 == NULL) {
2985             SWIG_null_ref("wxBitmap");
2986         }
2987         if (SWIG_arg_fail(2)) SWIG_fail;
2988     }
2989     {
2990         PyThreadState* __tstate = wxPyBeginAllowThreads();
2991         (arg1)->SetBitmapDisabled((wxBitmap const &)*arg2);
2992
2993         wxPyEndAllowThreads(__tstate);
2994         if (PyErr_Occurred()) SWIG_fail;
2995     }
2996     Py_INCREF(Py_None); resultobj = Py_None;
2997     return resultobj;
2998     fail:
2999     return NULL;
3000 }
3001
3002
3003 static PyObject *_wrap_BitmapButton_SetBitmapFocus(PyObject *, PyObject *args, PyObject *kwargs) {
3004     PyObject *resultobj;
3005     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3006     wxBitmap *arg2 = 0 ;
3007     PyObject * obj0 = 0 ;
3008     PyObject * obj1 = 0 ;
3009     char *kwnames[] = {
3010         (char *) "self",(char *) "bitmap", NULL
3011     };
3012
3013     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapFocus",kwnames,&obj0,&obj1)) goto fail;
3014     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3015     if (SWIG_arg_fail(1)) SWIG_fail;
3016     {
3017         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3018         if (SWIG_arg_fail(2)) SWIG_fail;
3019         if (arg2 == NULL) {
3020             SWIG_null_ref("wxBitmap");
3021         }
3022         if (SWIG_arg_fail(2)) SWIG_fail;
3023     }
3024     {
3025         PyThreadState* __tstate = wxPyBeginAllowThreads();
3026         (arg1)->SetBitmapFocus((wxBitmap const &)*arg2);
3027
3028         wxPyEndAllowThreads(__tstate);
3029         if (PyErr_Occurred()) SWIG_fail;
3030     }
3031     Py_INCREF(Py_None); resultobj = Py_None;
3032     return resultobj;
3033     fail:
3034     return NULL;
3035 }
3036
3037
3038 static PyObject *_wrap_BitmapButton_SetBitmapSelected(PyObject *, PyObject *args, PyObject *kwargs) {
3039     PyObject *resultobj;
3040     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3041     wxBitmap *arg2 = 0 ;
3042     PyObject * obj0 = 0 ;
3043     PyObject * obj1 = 0 ;
3044     char *kwnames[] = {
3045         (char *) "self",(char *) "bitmap", NULL
3046     };
3047
3048     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapSelected",kwnames,&obj0,&obj1)) goto fail;
3049     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3050     if (SWIG_arg_fail(1)) SWIG_fail;
3051     {
3052         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3053         if (SWIG_arg_fail(2)) SWIG_fail;
3054         if (arg2 == NULL) {
3055             SWIG_null_ref("wxBitmap");
3056         }
3057         if (SWIG_arg_fail(2)) SWIG_fail;
3058     }
3059     {
3060         PyThreadState* __tstate = wxPyBeginAllowThreads();
3061         (arg1)->SetBitmapSelected((wxBitmap const &)*arg2);
3062
3063         wxPyEndAllowThreads(__tstate);
3064         if (PyErr_Occurred()) SWIG_fail;
3065     }
3066     Py_INCREF(Py_None); resultobj = Py_None;
3067     return resultobj;
3068     fail:
3069     return NULL;
3070 }
3071
3072
3073 static PyObject *_wrap_BitmapButton_SetBitmapLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3074     PyObject *resultobj;
3075     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3076     wxBitmap *arg2 = 0 ;
3077     PyObject * obj0 = 0 ;
3078     PyObject * obj1 = 0 ;
3079     char *kwnames[] = {
3080         (char *) "self",(char *) "bitmap", NULL
3081     };
3082
3083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapLabel",kwnames,&obj0,&obj1)) goto fail;
3084     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3085     if (SWIG_arg_fail(1)) SWIG_fail;
3086     {
3087         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3088         if (SWIG_arg_fail(2)) SWIG_fail;
3089         if (arg2 == NULL) {
3090             SWIG_null_ref("wxBitmap");
3091         }
3092         if (SWIG_arg_fail(2)) SWIG_fail;
3093     }
3094     {
3095         PyThreadState* __tstate = wxPyBeginAllowThreads();
3096         (arg1)->SetBitmapLabel((wxBitmap const &)*arg2);
3097
3098         wxPyEndAllowThreads(__tstate);
3099         if (PyErr_Occurred()) SWIG_fail;
3100     }
3101     Py_INCREF(Py_None); resultobj = Py_None;
3102     return resultobj;
3103     fail:
3104     return NULL;
3105 }
3106
3107
3108 static PyObject *_wrap_BitmapButton_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
3109     PyObject *resultobj;
3110     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3111     int arg2 ;
3112     int arg3 ;
3113     PyObject * obj0 = 0 ;
3114     PyObject * obj1 = 0 ;
3115     PyObject * obj2 = 0 ;
3116     char *kwnames[] = {
3117         (char *) "self",(char *) "x",(char *) "y", NULL
3118     };
3119
3120     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BitmapButton_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
3121     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3122     if (SWIG_arg_fail(1)) SWIG_fail;
3123     {
3124         arg2 = (int)(SWIG_As_int(obj1));
3125         if (SWIG_arg_fail(2)) SWIG_fail;
3126     }
3127     {
3128         arg3 = (int)(SWIG_As_int(obj2));
3129         if (SWIG_arg_fail(3)) SWIG_fail;
3130     }
3131     {
3132         PyThreadState* __tstate = wxPyBeginAllowThreads();
3133         (arg1)->SetMargins(arg2,arg3);
3134
3135         wxPyEndAllowThreads(__tstate);
3136         if (PyErr_Occurred()) SWIG_fail;
3137     }
3138     Py_INCREF(Py_None); resultobj = Py_None;
3139     return resultobj;
3140     fail:
3141     return NULL;
3142 }
3143
3144
3145 static PyObject *_wrap_BitmapButton_GetMarginX(PyObject *, PyObject *args, PyObject *kwargs) {
3146     PyObject *resultobj;
3147     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3148     int result;
3149     PyObject * obj0 = 0 ;
3150     char *kwnames[] = {
3151         (char *) "self", NULL
3152     };
3153
3154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetMarginX",kwnames,&obj0)) goto fail;
3155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3156     if (SWIG_arg_fail(1)) SWIG_fail;
3157     {
3158         PyThreadState* __tstate = wxPyBeginAllowThreads();
3159         result = (int)((wxBitmapButton const *)arg1)->GetMarginX();
3160
3161         wxPyEndAllowThreads(__tstate);
3162         if (PyErr_Occurred()) SWIG_fail;
3163     }
3164     {
3165         resultobj = SWIG_From_int((int)(result));
3166     }
3167     return resultobj;
3168     fail:
3169     return NULL;
3170 }
3171
3172
3173 static PyObject *_wrap_BitmapButton_GetMarginY(PyObject *, PyObject *args, PyObject *kwargs) {
3174     PyObject *resultobj;
3175     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3176     int result;
3177     PyObject * obj0 = 0 ;
3178     char *kwnames[] = {
3179         (char *) "self", NULL
3180     };
3181
3182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetMarginY",kwnames,&obj0)) goto fail;
3183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3184     if (SWIG_arg_fail(1)) SWIG_fail;
3185     {
3186         PyThreadState* __tstate = wxPyBeginAllowThreads();
3187         result = (int)((wxBitmapButton const *)arg1)->GetMarginY();
3188
3189         wxPyEndAllowThreads(__tstate);
3190         if (PyErr_Occurred()) SWIG_fail;
3191     }
3192     {
3193         resultobj = SWIG_From_int((int)(result));
3194     }
3195     return resultobj;
3196     fail:
3197     return NULL;
3198 }
3199
3200
3201 static PyObject * BitmapButton_swigregister(PyObject *, PyObject *args) {
3202     PyObject *obj;
3203     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3204     SWIG_TypeClientData(SWIGTYPE_p_wxBitmapButton, obj);
3205     Py_INCREF(obj);
3206     return Py_BuildValue((char *)"");
3207 }
3208 static int _wrap_CheckBoxNameStr_set(PyObject *) {
3209     PyErr_SetString(PyExc_TypeError,"Variable CheckBoxNameStr is read-only.");
3210     return 1;
3211 }
3212
3213
3214 static PyObject *_wrap_CheckBoxNameStr_get(void) {
3215     PyObject *pyobj;
3216
3217     {
3218 #if wxUSE_UNICODE
3219         pyobj = PyUnicode_FromWideChar((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
3220 #else
3221         pyobj = PyString_FromStringAndSize((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
3222 #endif
3223     }
3224     return pyobj;
3225 }
3226
3227
3228 static PyObject *_wrap_new_CheckBox(PyObject *, PyObject *args, PyObject *kwargs) {
3229     PyObject *resultobj;
3230     wxWindow *arg1 = (wxWindow *) 0 ;
3231     int arg2 = (int) -1 ;
3232     wxString const &arg3_defvalue = wxPyEmptyString ;
3233     wxString *arg3 = (wxString *) &arg3_defvalue ;
3234     wxPoint const &arg4_defvalue = wxDefaultPosition ;
3235     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
3236     wxSize const &arg5_defvalue = wxDefaultSize ;
3237     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
3238     long arg6 = (long) 0 ;
3239     wxValidator const &arg7_defvalue = wxDefaultValidator ;
3240     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
3241     wxString const &arg8_defvalue = wxPyCheckBoxNameStr ;
3242     wxString *arg8 = (wxString *) &arg8_defvalue ;
3243     wxCheckBox *result;
3244     bool temp3 = false ;
3245     wxPoint temp4 ;
3246     wxSize temp5 ;
3247     bool temp8 = false ;
3248     PyObject * obj0 = 0 ;
3249     PyObject * obj1 = 0 ;
3250     PyObject * obj2 = 0 ;
3251     PyObject * obj3 = 0 ;
3252     PyObject * obj4 = 0 ;
3253     PyObject * obj5 = 0 ;
3254     PyObject * obj6 = 0 ;
3255     PyObject * obj7 = 0 ;
3256     char *kwnames[] = {
3257         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
3258     };
3259
3260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3262     if (SWIG_arg_fail(1)) SWIG_fail;
3263     if (obj1) {
3264         {
3265             arg2 = (int)(SWIG_As_int(obj1));
3266             if (SWIG_arg_fail(2)) SWIG_fail;
3267         }
3268     }
3269     if (obj2) {
3270         {
3271             arg3 = wxString_in_helper(obj2);
3272             if (arg3 == NULL) SWIG_fail;
3273             temp3 = true;
3274         }
3275     }
3276     if (obj3) {
3277         {
3278             arg4 = &temp4;
3279             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3280         }
3281     }
3282     if (obj4) {
3283         {
3284             arg5 = &temp5;
3285             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3286         }
3287     }
3288     if (obj5) {
3289         {
3290             arg6 = (long)(SWIG_As_long(obj5));
3291             if (SWIG_arg_fail(6)) SWIG_fail;
3292         }
3293     }
3294     if (obj6) {
3295         {
3296             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3297             if (SWIG_arg_fail(7)) SWIG_fail;
3298             if (arg7 == NULL) {
3299                 SWIG_null_ref("wxValidator");
3300             }
3301             if (SWIG_arg_fail(7)) SWIG_fail;
3302         }
3303     }
3304     if (obj7) {
3305         {
3306             arg8 = wxString_in_helper(obj7);
3307             if (arg8 == NULL) SWIG_fail;
3308             temp8 = true;
3309         }
3310     }
3311     {
3312         if (!wxPyCheckForApp()) SWIG_fail;
3313         PyThreadState* __tstate = wxPyBeginAllowThreads();
3314         result = (wxCheckBox *)new wxCheckBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
3315
3316         wxPyEndAllowThreads(__tstate);
3317         if (PyErr_Occurred()) SWIG_fail;
3318     }
3319     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckBox, 1);
3320     {
3321         if (temp3)
3322         delete arg3;
3323     }
3324     {
3325         if (temp8)
3326         delete arg8;
3327     }
3328     return resultobj;
3329     fail:
3330     {
3331         if (temp3)
3332         delete arg3;
3333     }
3334     {
3335         if (temp8)
3336         delete arg8;
3337     }
3338     return NULL;
3339 }
3340
3341
3342 static PyObject *_wrap_new_PreCheckBox(PyObject *, PyObject *args, PyObject *kwargs) {
3343     PyObject *resultobj;
3344     wxCheckBox *result;
3345     char *kwnames[] = {
3346         NULL
3347     };
3348
3349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreCheckBox",kwnames)) goto fail;
3350     {
3351         if (!wxPyCheckForApp()) SWIG_fail;
3352         PyThreadState* __tstate = wxPyBeginAllowThreads();
3353         result = (wxCheckBox *)new wxCheckBox();
3354
3355         wxPyEndAllowThreads(__tstate);
3356         if (PyErr_Occurred()) SWIG_fail;
3357     }
3358     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckBox, 1);
3359     return resultobj;
3360     fail:
3361     return NULL;
3362 }
3363
3364
3365 static PyObject *_wrap_CheckBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3366     PyObject *resultobj;
3367     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3368     wxWindow *arg2 = (wxWindow *) 0 ;
3369     int arg3 = (int) -1 ;
3370     wxString const &arg4_defvalue = wxPyEmptyString ;
3371     wxString *arg4 = (wxString *) &arg4_defvalue ;
3372     wxPoint const &arg5_defvalue = wxDefaultPosition ;
3373     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
3374     wxSize const &arg6_defvalue = wxDefaultSize ;
3375     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
3376     long arg7 = (long) 0 ;
3377     wxValidator const &arg8_defvalue = wxDefaultValidator ;
3378     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
3379     wxString const &arg9_defvalue = wxPyCheckBoxNameStr ;
3380     wxString *arg9 = (wxString *) &arg9_defvalue ;
3381     bool result;
3382     bool temp4 = false ;
3383     wxPoint temp5 ;
3384     wxSize temp6 ;
3385     bool temp9 = false ;
3386     PyObject * obj0 = 0 ;
3387     PyObject * obj1 = 0 ;
3388     PyObject * obj2 = 0 ;
3389     PyObject * obj3 = 0 ;
3390     PyObject * obj4 = 0 ;
3391     PyObject * obj5 = 0 ;
3392     PyObject * obj6 = 0 ;
3393     PyObject * obj7 = 0 ;
3394     PyObject * obj8 = 0 ;
3395     char *kwnames[] = {
3396         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
3397     };
3398
3399     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3400     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3401     if (SWIG_arg_fail(1)) SWIG_fail;
3402     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3403     if (SWIG_arg_fail(2)) SWIG_fail;
3404     if (obj2) {
3405         {
3406             arg3 = (int)(SWIG_As_int(obj2));
3407             if (SWIG_arg_fail(3)) SWIG_fail;
3408         }
3409     }
3410     if (obj3) {
3411         {
3412             arg4 = wxString_in_helper(obj3);
3413             if (arg4 == NULL) SWIG_fail;
3414             temp4 = true;
3415         }
3416     }
3417     if (obj4) {
3418         {
3419             arg5 = &temp5;
3420             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
3421         }
3422     }
3423     if (obj5) {
3424         {
3425             arg6 = &temp6;
3426             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
3427         }
3428     }
3429     if (obj6) {
3430         {
3431             arg7 = (long)(SWIG_As_long(obj6));
3432             if (SWIG_arg_fail(7)) SWIG_fail;
3433         }
3434     }
3435     if (obj7) {
3436         {
3437             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3438             if (SWIG_arg_fail(8)) SWIG_fail;
3439             if (arg8 == NULL) {
3440                 SWIG_null_ref("wxValidator");
3441             }
3442             if (SWIG_arg_fail(8)) SWIG_fail;
3443         }
3444     }
3445     if (obj8) {
3446         {
3447             arg9 = wxString_in_helper(obj8);
3448             if (arg9 == NULL) SWIG_fail;
3449             temp9 = true;
3450         }
3451     }
3452     {
3453         PyThreadState* __tstate = wxPyBeginAllowThreads();
3454         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
3455
3456         wxPyEndAllowThreads(__tstate);
3457         if (PyErr_Occurred()) SWIG_fail;
3458     }
3459     {
3460         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3461     }
3462     {
3463         if (temp4)
3464         delete arg4;
3465     }
3466     {
3467         if (temp9)
3468         delete arg9;
3469     }
3470     return resultobj;
3471     fail:
3472     {
3473         if (temp4)
3474         delete arg4;
3475     }
3476     {
3477         if (temp9)
3478         delete arg9;
3479     }
3480     return NULL;
3481 }
3482
3483
3484 static PyObject *_wrap_CheckBox_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
3485     PyObject *resultobj;
3486     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3487     bool result;
3488     PyObject * obj0 = 0 ;
3489     char *kwnames[] = {
3490         (char *) "self", NULL
3491     };
3492
3493     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_GetValue",kwnames,&obj0)) goto fail;
3494     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3495     if (SWIG_arg_fail(1)) SWIG_fail;
3496     {
3497         PyThreadState* __tstate = wxPyBeginAllowThreads();
3498         result = (bool)(arg1)->GetValue();
3499
3500         wxPyEndAllowThreads(__tstate);
3501         if (PyErr_Occurred()) SWIG_fail;
3502     }
3503     {
3504         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3505     }
3506     return resultobj;
3507     fail:
3508     return NULL;
3509 }
3510
3511
3512 static PyObject *_wrap_CheckBox_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
3513     PyObject *resultobj;
3514     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3515     bool result;
3516     PyObject * obj0 = 0 ;
3517     char *kwnames[] = {
3518         (char *) "self", NULL
3519     };
3520
3521     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_IsChecked",kwnames,&obj0)) goto fail;
3522     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3523     if (SWIG_arg_fail(1)) SWIG_fail;
3524     {
3525         PyThreadState* __tstate = wxPyBeginAllowThreads();
3526         result = (bool)(arg1)->IsChecked();
3527
3528         wxPyEndAllowThreads(__tstate);
3529         if (PyErr_Occurred()) SWIG_fail;
3530     }
3531     {
3532         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3533     }
3534     return resultobj;
3535     fail:
3536     return NULL;
3537 }
3538
3539
3540 static PyObject *_wrap_CheckBox_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
3541     PyObject *resultobj;
3542     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3543     bool arg2 ;
3544     PyObject * obj0 = 0 ;
3545     PyObject * obj1 = 0 ;
3546     char *kwnames[] = {
3547         (char *) "self",(char *) "state", NULL
3548     };
3549
3550     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_SetValue",kwnames,&obj0,&obj1)) goto fail;
3551     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3552     if (SWIG_arg_fail(1)) SWIG_fail;
3553     {
3554         arg2 = (bool const)(SWIG_As_bool(obj1));
3555         if (SWIG_arg_fail(2)) SWIG_fail;
3556     }
3557     {
3558         PyThreadState* __tstate = wxPyBeginAllowThreads();
3559         (arg1)->SetValue(arg2);
3560
3561         wxPyEndAllowThreads(__tstate);
3562         if (PyErr_Occurred()) SWIG_fail;
3563     }
3564     Py_INCREF(Py_None); resultobj = Py_None;
3565     return resultobj;
3566     fail:
3567     return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_CheckBox_Get3StateValue(PyObject *, PyObject *args, PyObject *kwargs) {
3572     PyObject *resultobj;
3573     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3574     wxCheckBoxState result;
3575     PyObject * obj0 = 0 ;
3576     char *kwnames[] = {
3577         (char *) "self", NULL
3578     };
3579
3580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Get3StateValue",kwnames,&obj0)) goto fail;
3581     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3582     if (SWIG_arg_fail(1)) SWIG_fail;
3583     {
3584         PyThreadState* __tstate = wxPyBeginAllowThreads();
3585         result = (wxCheckBoxState)((wxCheckBox const *)arg1)->Get3StateValue();
3586
3587         wxPyEndAllowThreads(__tstate);
3588         if (PyErr_Occurred()) SWIG_fail;
3589     }
3590     resultobj = SWIG_From_int((result));
3591     return resultobj;
3592     fail:
3593     return NULL;
3594 }
3595
3596
3597 static PyObject *_wrap_CheckBox_Set3StateValue(PyObject *, PyObject *args, PyObject *kwargs) {
3598     PyObject *resultobj;
3599     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3600     wxCheckBoxState arg2 ;
3601     PyObject * obj0 = 0 ;
3602     PyObject * obj1 = 0 ;
3603     char *kwnames[] = {
3604         (char *) "self",(char *) "state", NULL
3605     };
3606
3607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_Set3StateValue",kwnames,&obj0,&obj1)) goto fail;
3608     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3609     if (SWIG_arg_fail(1)) SWIG_fail;
3610     {
3611         arg2 = (wxCheckBoxState)(SWIG_As_int(obj1));
3612         if (SWIG_arg_fail(2)) SWIG_fail;
3613     }
3614     {
3615         PyThreadState* __tstate = wxPyBeginAllowThreads();
3616         (arg1)->Set3StateValue((wxCheckBoxState )arg2);
3617
3618         wxPyEndAllowThreads(__tstate);
3619         if (PyErr_Occurred()) SWIG_fail;
3620     }
3621     Py_INCREF(Py_None); resultobj = Py_None;
3622     return resultobj;
3623     fail:
3624     return NULL;
3625 }
3626
3627
3628 static PyObject *_wrap_CheckBox_Is3State(PyObject *, PyObject *args, PyObject *kwargs) {
3629     PyObject *resultobj;
3630     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3631     bool result;
3632     PyObject * obj0 = 0 ;
3633     char *kwnames[] = {
3634         (char *) "self", NULL
3635     };
3636
3637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Is3State",kwnames,&obj0)) goto fail;
3638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3639     if (SWIG_arg_fail(1)) SWIG_fail;
3640     {
3641         PyThreadState* __tstate = wxPyBeginAllowThreads();
3642         result = (bool)((wxCheckBox const *)arg1)->Is3State();
3643
3644         wxPyEndAllowThreads(__tstate);
3645         if (PyErr_Occurred()) SWIG_fail;
3646     }
3647     {
3648         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3649     }
3650     return resultobj;
3651     fail:
3652     return NULL;
3653 }
3654
3655
3656 static PyObject *_wrap_CheckBox_Is3rdStateAllowedForUser(PyObject *, PyObject *args, PyObject *kwargs) {
3657     PyObject *resultobj;
3658     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3659     bool result;
3660     PyObject * obj0 = 0 ;
3661     char *kwnames[] = {
3662         (char *) "self", NULL
3663     };
3664
3665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Is3rdStateAllowedForUser",kwnames,&obj0)) goto fail;
3666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3667     if (SWIG_arg_fail(1)) SWIG_fail;
3668     {
3669         PyThreadState* __tstate = wxPyBeginAllowThreads();
3670         result = (bool)((wxCheckBox const *)arg1)->Is3rdStateAllowedForUser();
3671
3672         wxPyEndAllowThreads(__tstate);
3673         if (PyErr_Occurred()) SWIG_fail;
3674     }
3675     {
3676         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3677     }
3678     return resultobj;
3679     fail:
3680     return NULL;
3681 }
3682
3683
3684 static PyObject *_wrap_CheckBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3685     PyObject *resultobj;
3686     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3687     wxVisualAttributes result;
3688     PyObject * obj0 = 0 ;
3689     char *kwnames[] = {
3690         (char *) "variant", NULL
3691     };
3692
3693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:CheckBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3694     if (obj0) {
3695         {
3696             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
3697             if (SWIG_arg_fail(1)) SWIG_fail;
3698         }
3699     }
3700     {
3701         if (!wxPyCheckForApp()) SWIG_fail;
3702         PyThreadState* __tstate = wxPyBeginAllowThreads();
3703         result = wxCheckBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
3704
3705         wxPyEndAllowThreads(__tstate);
3706         if (PyErr_Occurred()) SWIG_fail;
3707     }
3708     {
3709         wxVisualAttributes * resultptr;
3710         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
3711         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
3712     }
3713     return resultobj;
3714     fail:
3715     return NULL;
3716 }
3717
3718
3719 static PyObject * CheckBox_swigregister(PyObject *, PyObject *args) {
3720     PyObject *obj;
3721     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3722     SWIG_TypeClientData(SWIGTYPE_p_wxCheckBox, obj);
3723     Py_INCREF(obj);
3724     return Py_BuildValue((char *)"");
3725 }
3726 static int _wrap_ChoiceNameStr_set(PyObject *) {
3727     PyErr_SetString(PyExc_TypeError,"Variable ChoiceNameStr is read-only.");
3728     return 1;
3729 }
3730
3731
3732 static PyObject *_wrap_ChoiceNameStr_get(void) {
3733     PyObject *pyobj;
3734
3735     {
3736 #if wxUSE_UNICODE
3737         pyobj = PyUnicode_FromWideChar((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
3738 #else
3739         pyobj = PyString_FromStringAndSize((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
3740 #endif
3741     }
3742     return pyobj;
3743 }
3744
3745
3746 static PyObject *_wrap_new_Choice(PyObject *, PyObject *args, PyObject *kwargs) {
3747     PyObject *resultobj;
3748     wxWindow *arg1 = (wxWindow *) 0 ;
3749     int arg2 = (int) -1 ;
3750     wxPoint const &arg3_defvalue = wxDefaultPosition ;
3751     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
3752     wxSize const &arg4_defvalue = wxDefaultSize ;
3753     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
3754     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
3755     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
3756     long arg6 = (long) 0 ;
3757     wxValidator const &arg7_defvalue = wxDefaultValidator ;
3758     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
3759     wxString const &arg8_defvalue = wxPyChoiceNameStr ;
3760     wxString *arg8 = (wxString *) &arg8_defvalue ;
3761     wxChoice *result;
3762     wxPoint temp3 ;
3763     wxSize temp4 ;
3764     bool temp5 = false ;
3765     bool temp8 = false ;
3766     PyObject * obj0 = 0 ;
3767     PyObject * obj1 = 0 ;
3768     PyObject * obj2 = 0 ;
3769     PyObject * obj3 = 0 ;
3770     PyObject * obj4 = 0 ;
3771     PyObject * obj5 = 0 ;
3772     PyObject * obj6 = 0 ;
3773     PyObject * obj7 = 0 ;
3774     char *kwnames[] = {
3775         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
3776     };
3777
3778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Choice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3780     if (SWIG_arg_fail(1)) SWIG_fail;
3781     if (obj1) {
3782         {
3783             arg2 = (int)(SWIG_As_int(obj1));
3784             if (SWIG_arg_fail(2)) SWIG_fail;
3785         }
3786     }
3787     if (obj2) {
3788         {
3789             arg3 = &temp3;
3790             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
3791         }
3792     }
3793     if (obj3) {
3794         {
3795             arg4 = &temp4;
3796             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
3797         }
3798     }
3799     if (obj4) {
3800         {
3801             if (! PySequence_Check(obj4)) {
3802                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
3803                 SWIG_fail;
3804             }
3805             arg5 = new wxArrayString;
3806             temp5 = true;
3807             int i, len=PySequence_Length(obj4);
3808             for (i=0; i<len; i++) {
3809                 PyObject* item = PySequence_GetItem(obj4, i);
3810 #if wxUSE_UNICODE
3811                 PyObject* str  = PyObject_Unicode(item);
3812 #else
3813                 PyObject* str  = PyObject_Str(item);
3814 #endif
3815                 if (PyErr_Occurred())  SWIG_fail;
3816                 arg5->Add(Py2wxString(str));
3817                 Py_DECREF(item);
3818                 Py_DECREF(str);
3819             }
3820         }
3821     }
3822     if (obj5) {
3823         {
3824             arg6 = (long)(SWIG_As_long(obj5));
3825             if (SWIG_arg_fail(6)) SWIG_fail;
3826         }
3827     }
3828     if (obj6) {
3829         {
3830             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3831             if (SWIG_arg_fail(7)) SWIG_fail;
3832             if (arg7 == NULL) {
3833                 SWIG_null_ref("wxValidator");
3834             }
3835             if (SWIG_arg_fail(7)) SWIG_fail;
3836         }
3837     }
3838     if (obj7) {
3839         {
3840             arg8 = wxString_in_helper(obj7);
3841             if (arg8 == NULL) SWIG_fail;
3842             temp8 = true;
3843         }
3844     }
3845     {
3846         if (!wxPyCheckForApp()) SWIG_fail;
3847         PyThreadState* __tstate = wxPyBeginAllowThreads();
3848         result = (wxChoice *)new wxChoice(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
3849
3850         wxPyEndAllowThreads(__tstate);
3851         if (PyErr_Occurred()) SWIG_fail;
3852     }
3853     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoice, 1);
3854     {
3855         if (temp5) delete arg5;
3856     }
3857     {
3858         if (temp8)
3859         delete arg8;
3860     }
3861     return resultobj;
3862     fail:
3863     {
3864         if (temp5) delete arg5;
3865     }
3866     {
3867         if (temp8)
3868         delete arg8;
3869     }
3870     return NULL;
3871 }
3872
3873
3874 static PyObject *_wrap_new_PreChoice(PyObject *, PyObject *args, PyObject *kwargs) {
3875     PyObject *resultobj;
3876     wxChoice *result;
3877     char *kwnames[] = {
3878         NULL
3879     };
3880
3881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreChoice",kwnames)) goto fail;
3882     {
3883         if (!wxPyCheckForApp()) SWIG_fail;
3884         PyThreadState* __tstate = wxPyBeginAllowThreads();
3885         result = (wxChoice *)new wxChoice();
3886
3887         wxPyEndAllowThreads(__tstate);
3888         if (PyErr_Occurred()) SWIG_fail;
3889     }
3890     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoice, 1);
3891     return resultobj;
3892     fail:
3893     return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Choice_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3898     PyObject *resultobj;
3899     wxChoice *arg1 = (wxChoice *) 0 ;
3900     wxWindow *arg2 = (wxWindow *) 0 ;
3901     int arg3 = (int) -1 ;
3902     wxPoint const &arg4_defvalue = wxDefaultPosition ;
3903     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
3904     wxSize const &arg5_defvalue = wxDefaultSize ;
3905     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
3906     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
3907     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
3908     long arg7 = (long) 0 ;
3909     wxValidator const &arg8_defvalue = wxDefaultValidator ;
3910     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
3911     wxString const &arg9_defvalue = wxPyChoiceNameStr ;
3912     wxString *arg9 = (wxString *) &arg9_defvalue ;
3913     bool result;
3914     wxPoint temp4 ;
3915     wxSize temp5 ;
3916     bool temp6 = false ;
3917     bool temp9 = false ;
3918     PyObject * obj0 = 0 ;
3919     PyObject * obj1 = 0 ;
3920     PyObject * obj2 = 0 ;
3921     PyObject * obj3 = 0 ;
3922     PyObject * obj4 = 0 ;
3923     PyObject * obj5 = 0 ;
3924     PyObject * obj6 = 0 ;
3925     PyObject * obj7 = 0 ;
3926     PyObject * obj8 = 0 ;
3927     char *kwnames[] = {
3928         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
3929     };
3930
3931     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Choice_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3932     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
3933     if (SWIG_arg_fail(1)) SWIG_fail;
3934     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3935     if (SWIG_arg_fail(2)) SWIG_fail;
3936     if (obj2) {
3937         {
3938             arg3 = (int)(SWIG_As_int(obj2));
3939             if (SWIG_arg_fail(3)) SWIG_fail;
3940         }
3941     }
3942     if (obj3) {
3943         {
3944             arg4 = &temp4;
3945             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3946         }
3947     }
3948     if (obj4) {
3949         {
3950             arg5 = &temp5;
3951             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3952         }
3953     }
3954     if (obj5) {
3955         {
3956             if (! PySequence_Check(obj5)) {
3957                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
3958                 SWIG_fail;
3959             }
3960             arg6 = new wxArrayString;
3961             temp6 = true;
3962             int i, len=PySequence_Length(obj5);
3963             for (i=0; i<len; i++) {
3964                 PyObject* item = PySequence_GetItem(obj5, i);
3965 #if wxUSE_UNICODE
3966                 PyObject* str  = PyObject_Unicode(item);
3967 #else
3968                 PyObject* str  = PyObject_Str(item);
3969 #endif
3970                 if (PyErr_Occurred())  SWIG_fail;
3971                 arg6->Add(Py2wxString(str));
3972                 Py_DECREF(item);
3973                 Py_DECREF(str);
3974             }
3975         }
3976     }
3977     if (obj6) {
3978         {
3979             arg7 = (long)(SWIG_As_long(obj6));
3980             if (SWIG_arg_fail(7)) SWIG_fail;
3981         }
3982     }
3983     if (obj7) {
3984         {
3985             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3986             if (SWIG_arg_fail(8)) SWIG_fail;
3987             if (arg8 == NULL) {
3988                 SWIG_null_ref("wxValidator");
3989             }
3990             if (SWIG_arg_fail(8)) SWIG_fail;
3991         }
3992     }
3993     if (obj8) {
3994         {
3995             arg9 = wxString_in_helper(obj8);
3996             if (arg9 == NULL) SWIG_fail;
3997             temp9 = true;
3998         }
3999     }
4000     {
4001         PyThreadState* __tstate = wxPyBeginAllowThreads();
4002         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
4003
4004         wxPyEndAllowThreads(__tstate);
4005         if (PyErr_Occurred()) SWIG_fail;
4006     }
4007     {
4008         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4009     }
4010     {
4011         if (temp6) delete arg6;
4012     }
4013     {
4014         if (temp9)
4015         delete arg9;
4016     }
4017     return resultobj;
4018     fail:
4019     {
4020         if (temp6) delete arg6;
4021     }
4022     {
4023         if (temp9)
4024         delete arg9;
4025     }
4026     return NULL;
4027 }
4028
4029
4030 static PyObject *_wrap_Choice_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4031     PyObject *resultobj;
4032     wxChoice *arg1 = (wxChoice *) 0 ;
4033     int arg2 ;
4034     PyObject * obj0 = 0 ;
4035     PyObject * obj1 = 0 ;
4036     char *kwnames[] = {
4037         (char *) "self",(char *) "n", NULL
4038     };
4039
4040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Choice_SetSelection",kwnames,&obj0,&obj1)) goto fail;
4041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4042     if (SWIG_arg_fail(1)) SWIG_fail;
4043     {
4044         arg2 = (int const)(SWIG_As_int(obj1));
4045         if (SWIG_arg_fail(2)) SWIG_fail;
4046     }
4047     {
4048         PyThreadState* __tstate = wxPyBeginAllowThreads();
4049         (arg1)->SetSelection(arg2);
4050
4051         wxPyEndAllowThreads(__tstate);
4052         if (PyErr_Occurred()) SWIG_fail;
4053     }
4054     Py_INCREF(Py_None); resultobj = Py_None;
4055     return resultobj;
4056     fail:
4057     return NULL;
4058 }
4059
4060
4061 static PyObject *_wrap_Choice_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4062     PyObject *resultobj;
4063     wxChoice *arg1 = (wxChoice *) 0 ;
4064     wxString *arg2 = 0 ;
4065     bool result;
4066     bool temp2 = false ;
4067     PyObject * obj0 = 0 ;
4068     PyObject * obj1 = 0 ;
4069     char *kwnames[] = {
4070         (char *) "self",(char *) "string", NULL
4071     };
4072
4073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Choice_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
4074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4075     if (SWIG_arg_fail(1)) SWIG_fail;
4076     {
4077         arg2 = wxString_in_helper(obj1);
4078         if (arg2 == NULL) SWIG_fail;
4079         temp2 = true;
4080     }
4081     {
4082         PyThreadState* __tstate = wxPyBeginAllowThreads();
4083         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
4084
4085         wxPyEndAllowThreads(__tstate);
4086         if (PyErr_Occurred()) SWIG_fail;
4087     }
4088     {
4089         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4090     }
4091     {
4092         if (temp2)
4093         delete arg2;
4094     }
4095     return resultobj;
4096     fail:
4097     {
4098         if (temp2)
4099         delete arg2;
4100     }
4101     return NULL;
4102 }
4103
4104
4105 static PyObject *_wrap_Choice_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
4106     PyObject *resultobj;
4107     wxChoice *arg1 = (wxChoice *) 0 ;
4108     int arg2 ;
4109     wxString *arg3 = 0 ;
4110     bool temp3 = false ;
4111     PyObject * obj0 = 0 ;
4112     PyObject * obj1 = 0 ;
4113     PyObject * obj2 = 0 ;
4114     char *kwnames[] = {
4115         (char *) "self",(char *) "n",(char *) "string", NULL
4116     };
4117
4118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Choice_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
4119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4120     if (SWIG_arg_fail(1)) SWIG_fail;
4121     {
4122         arg2 = (int)(SWIG_As_int(obj1));
4123         if (SWIG_arg_fail(2)) SWIG_fail;
4124     }
4125     {
4126         arg3 = wxString_in_helper(obj2);
4127         if (arg3 == NULL) SWIG_fail;
4128         temp3 = true;
4129     }
4130     {
4131         PyThreadState* __tstate = wxPyBeginAllowThreads();
4132         (arg1)->SetString(arg2,(wxString const &)*arg3);
4133
4134         wxPyEndAllowThreads(__tstate);
4135         if (PyErr_Occurred()) SWIG_fail;
4136     }
4137     Py_INCREF(Py_None); resultobj = Py_None;
4138     {
4139         if (temp3)
4140         delete arg3;
4141     }
4142     return resultobj;
4143     fail:
4144     {
4145         if (temp3)
4146         delete arg3;
4147     }
4148     return NULL;
4149 }
4150
4151
4152 static PyObject *_wrap_Choice_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
4153     PyObject *resultobj;
4154     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
4155     wxVisualAttributes result;
4156     PyObject * obj0 = 0 ;
4157     char *kwnames[] = {
4158         (char *) "variant", NULL
4159     };
4160
4161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Choice_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
4162     if (obj0) {
4163         {
4164             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
4165             if (SWIG_arg_fail(1)) SWIG_fail;
4166         }
4167     }
4168     {
4169         if (!wxPyCheckForApp()) SWIG_fail;
4170         PyThreadState* __tstate = wxPyBeginAllowThreads();
4171         result = wxChoice::GetClassDefaultAttributes((wxWindowVariant )arg1);
4172
4173         wxPyEndAllowThreads(__tstate);
4174         if (PyErr_Occurred()) SWIG_fail;
4175     }
4176     {
4177         wxVisualAttributes * resultptr;
4178         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
4179         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
4180     }
4181     return resultobj;
4182     fail:
4183     return NULL;
4184 }
4185
4186
4187 static PyObject * Choice_swigregister(PyObject *, PyObject *args) {
4188     PyObject *obj;
4189     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4190     SWIG_TypeClientData(SWIGTYPE_p_wxChoice, obj);
4191     Py_INCREF(obj);
4192     return Py_BuildValue((char *)"");
4193 }
4194 static int _wrap_ComboBoxNameStr_set(PyObject *) {
4195     PyErr_SetString(PyExc_TypeError,"Variable ComboBoxNameStr is read-only.");
4196     return 1;
4197 }
4198
4199
4200 static PyObject *_wrap_ComboBoxNameStr_get(void) {
4201     PyObject *pyobj;
4202
4203     {
4204 #if wxUSE_UNICODE
4205         pyobj = PyUnicode_FromWideChar((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
4206 #else
4207         pyobj = PyString_FromStringAndSize((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
4208 #endif
4209     }
4210     return pyobj;
4211 }
4212
4213
4214 static PyObject *_wrap_new_ComboBox(PyObject *, PyObject *args, PyObject *kwargs) {
4215     PyObject *resultobj;
4216     wxWindow *arg1 = (wxWindow *) 0 ;
4217     int arg2 = (int) -1 ;
4218     wxString const &arg3_defvalue = wxPyEmptyString ;
4219     wxString *arg3 = (wxString *) &arg3_defvalue ;
4220     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4221     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4222     wxSize const &arg5_defvalue = wxDefaultSize ;
4223     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4224     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
4225     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
4226     long arg7 = (long) 0 ;
4227     wxValidator const &arg8_defvalue = wxDefaultValidator ;
4228     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
4229     wxString const &arg9_defvalue = wxPyComboBoxNameStr ;
4230     wxString *arg9 = (wxString *) &arg9_defvalue ;
4231     wxComboBox *result;
4232     bool temp3 = false ;
4233     wxPoint temp4 ;
4234     wxSize temp5 ;
4235     bool temp6 = false ;
4236     bool temp9 = false ;
4237     PyObject * obj0 = 0 ;
4238     PyObject * obj1 = 0 ;
4239     PyObject * obj2 = 0 ;
4240     PyObject * obj3 = 0 ;
4241     PyObject * obj4 = 0 ;
4242     PyObject * obj5 = 0 ;
4243     PyObject * obj6 = 0 ;
4244     PyObject * obj7 = 0 ;
4245     PyObject * obj8 = 0 ;
4246     char *kwnames[] = {
4247         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
4248     };
4249
4250     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_ComboBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4251     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4252     if (SWIG_arg_fail(1)) SWIG_fail;
4253     if (obj1) {
4254         {
4255             arg2 = (int)(SWIG_As_int(obj1));
4256             if (SWIG_arg_fail(2)) SWIG_fail;
4257         }
4258     }
4259     if (obj2) {
4260         {
4261             arg3 = wxString_in_helper(obj2);
4262             if (arg3 == NULL) SWIG_fail;
4263             temp3 = true;
4264         }
4265     }
4266     if (obj3) {
4267         {
4268             arg4 = &temp4;
4269             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4270         }
4271     }
4272     if (obj4) {
4273         {
4274             arg5 = &temp5;
4275             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4276         }
4277     }
4278     if (obj5) {
4279         {
4280             if (! PySequence_Check(obj5)) {
4281                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
4282                 SWIG_fail;
4283             }
4284             arg6 = new wxArrayString;
4285             temp6 = true;
4286             int i, len=PySequence_Length(obj5);
4287             for (i=0; i<len; i++) {
4288                 PyObject* item = PySequence_GetItem(obj5, i);
4289 #if wxUSE_UNICODE
4290                 PyObject* str  = PyObject_Unicode(item);
4291 #else
4292                 PyObject* str  = PyObject_Str(item);
4293 #endif
4294                 if (PyErr_Occurred())  SWIG_fail;
4295                 arg6->Add(Py2wxString(str));
4296                 Py_DECREF(item);
4297                 Py_DECREF(str);
4298             }
4299         }
4300     }
4301     if (obj6) {
4302         {
4303             arg7 = (long)(SWIG_As_long(obj6));
4304             if (SWIG_arg_fail(7)) SWIG_fail;
4305         }
4306     }
4307     if (obj7) {
4308         {
4309             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
4310             if (SWIG_arg_fail(8)) SWIG_fail;
4311             if (arg8 == NULL) {
4312                 SWIG_null_ref("wxValidator");
4313             }
4314             if (SWIG_arg_fail(8)) SWIG_fail;
4315         }
4316     }
4317     if (obj8) {
4318         {
4319             arg9 = wxString_in_helper(obj8);
4320             if (arg9 == NULL) SWIG_fail;
4321             temp9 = true;
4322         }
4323     }
4324     {
4325         if (!wxPyCheckForApp()) SWIG_fail;
4326         PyThreadState* __tstate = wxPyBeginAllowThreads();
4327         result = (wxComboBox *)new wxComboBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
4328
4329         wxPyEndAllowThreads(__tstate);
4330         if (PyErr_Occurred()) SWIG_fail;
4331     }
4332     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxComboBox, 1);
4333     {
4334         if (temp3)
4335         delete arg3;
4336     }
4337     {
4338         if (temp6) delete arg6;
4339     }
4340     {
4341         if (temp9)
4342         delete arg9;
4343     }
4344     return resultobj;
4345     fail:
4346     {
4347         if (temp3)
4348         delete arg3;
4349     }
4350     {
4351         if (temp6) delete arg6;
4352     }
4353     {
4354         if (temp9)
4355         delete arg9;
4356     }
4357     return NULL;
4358 }
4359
4360
4361 static PyObject *_wrap_new_PreComboBox(PyObject *, PyObject *args, PyObject *kwargs) {
4362     PyObject *resultobj;
4363     wxComboBox *result;
4364     char *kwnames[] = {
4365         NULL
4366     };
4367
4368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreComboBox",kwnames)) goto fail;
4369     {
4370         if (!wxPyCheckForApp()) SWIG_fail;
4371         PyThreadState* __tstate = wxPyBeginAllowThreads();
4372         result = (wxComboBox *)new wxComboBox();
4373
4374         wxPyEndAllowThreads(__tstate);
4375         if (PyErr_Occurred()) SWIG_fail;
4376     }
4377     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxComboBox, 1);
4378     return resultobj;
4379     fail:
4380     return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_ComboBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4385     PyObject *resultobj;
4386     wxComboBox *arg1 = (wxComboBox *) 0 ;
4387     wxWindow *arg2 = (wxWindow *) 0 ;
4388     int arg3 = (int) -1 ;
4389     wxString const &arg4_defvalue = wxPyEmptyString ;
4390     wxString *arg4 = (wxString *) &arg4_defvalue ;
4391     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4392     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4393     wxSize const &arg6_defvalue = wxDefaultSize ;
4394     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4395     wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
4396     wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
4397     long arg8 = (long) 0 ;
4398     wxValidator const &arg9_defvalue = wxDefaultValidator ;
4399     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
4400     wxString const &arg10_defvalue = wxPyChoiceNameStr ;
4401     wxString *arg10 = (wxString *) &arg10_defvalue ;
4402     bool result;
4403     bool temp4 = false ;
4404     wxPoint temp5 ;
4405     wxSize temp6 ;
4406     bool temp7 = false ;
4407     bool temp10 = false ;
4408     PyObject * obj0 = 0 ;
4409     PyObject * obj1 = 0 ;
4410     PyObject * obj2 = 0 ;
4411     PyObject * obj3 = 0 ;
4412     PyObject * obj4 = 0 ;
4413     PyObject * obj5 = 0 ;
4414     PyObject * obj6 = 0 ;
4415     PyObject * obj7 = 0 ;
4416     PyObject * obj8 = 0 ;
4417     PyObject * obj9 = 0 ;
4418     char *kwnames[] = {
4419         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
4420     };
4421
4422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:ComboBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
4423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4424     if (SWIG_arg_fail(1)) SWIG_fail;
4425     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4426     if (SWIG_arg_fail(2)) SWIG_fail;
4427     if (obj2) {
4428         {
4429             arg3 = (int)(SWIG_As_int(obj2));
4430             if (SWIG_arg_fail(3)) SWIG_fail;
4431         }
4432     }
4433     if (obj3) {
4434         {
4435             arg4 = wxString_in_helper(obj3);
4436             if (arg4 == NULL) SWIG_fail;
4437             temp4 = true;
4438         }
4439     }
4440     if (obj4) {
4441         {
4442             arg5 = &temp5;
4443             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4444         }
4445     }
4446     if (obj5) {
4447         {
4448             arg6 = &temp6;
4449             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4450         }
4451     }
4452     if (obj6) {
4453         {
4454             if (! PySequence_Check(obj6)) {
4455                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
4456                 SWIG_fail;
4457             }
4458             arg7 = new wxArrayString;
4459             temp7 = true;
4460             int i, len=PySequence_Length(obj6);
4461             for (i=0; i<len; i++) {
4462                 PyObject* item = PySequence_GetItem(obj6, i);
4463 #if wxUSE_UNICODE
4464                 PyObject* str  = PyObject_Unicode(item);
4465 #else
4466                 PyObject* str  = PyObject_Str(item);
4467 #endif
4468                 if (PyErr_Occurred())  SWIG_fail;
4469                 arg7->Add(Py2wxString(str));
4470                 Py_DECREF(item);
4471                 Py_DECREF(str);
4472             }
4473         }
4474     }
4475     if (obj7) {
4476         {
4477             arg8 = (long)(SWIG_As_long(obj7));
4478             if (SWIG_arg_fail(8)) SWIG_fail;
4479         }
4480     }
4481     if (obj8) {
4482         {
4483             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
4484             if (SWIG_arg_fail(9)) SWIG_fail;
4485             if (arg9 == NULL) {
4486                 SWIG_null_ref("wxValidator");
4487             }
4488             if (SWIG_arg_fail(9)) SWIG_fail;
4489         }
4490     }
4491     if (obj9) {
4492         {
4493             arg10 = wxString_in_helper(obj9);
4494             if (arg10 == NULL) SWIG_fail;
4495             temp10 = true;
4496         }
4497     }
4498     {
4499         PyThreadState* __tstate = wxPyBeginAllowThreads();
4500         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
4501
4502         wxPyEndAllowThreads(__tstate);
4503         if (PyErr_Occurred()) SWIG_fail;
4504     }
4505     {
4506         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4507     }
4508     {
4509         if (temp4)
4510         delete arg4;
4511     }
4512     {
4513         if (temp7) delete arg7;
4514     }
4515     {
4516         if (temp10)
4517         delete arg10;
4518     }
4519     return resultobj;
4520     fail:
4521     {
4522         if (temp4)
4523         delete arg4;
4524     }
4525     {
4526         if (temp7) delete arg7;
4527     }
4528     {
4529         if (temp10)
4530         delete arg10;
4531     }
4532     return NULL;
4533 }
4534
4535
4536 static PyObject *_wrap_ComboBox_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4537     PyObject *resultobj;
4538     wxComboBox *arg1 = (wxComboBox *) 0 ;
4539     wxString result;
4540     PyObject * obj0 = 0 ;
4541     char *kwnames[] = {
4542         (char *) "self", NULL
4543     };
4544
4545     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetValue",kwnames,&obj0)) goto fail;
4546     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4547     if (SWIG_arg_fail(1)) SWIG_fail;
4548     {
4549         PyThreadState* __tstate = wxPyBeginAllowThreads();
4550         result = ((wxComboBox const *)arg1)->GetValue();
4551
4552         wxPyEndAllowThreads(__tstate);
4553         if (PyErr_Occurred()) SWIG_fail;
4554     }
4555     {
4556 #if wxUSE_UNICODE
4557         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4558 #else
4559         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4560 #endif
4561     }
4562     return resultobj;
4563     fail:
4564     return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_ComboBox_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4569     PyObject *resultobj;
4570     wxComboBox *arg1 = (wxComboBox *) 0 ;
4571     wxString *arg2 = 0 ;
4572     bool temp2 = false ;
4573     PyObject * obj0 = 0 ;
4574     PyObject * obj1 = 0 ;
4575     char *kwnames[] = {
4576         (char *) "self",(char *) "value", NULL
4577     };
4578
4579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetValue",kwnames,&obj0,&obj1)) goto fail;
4580     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4581     if (SWIG_arg_fail(1)) SWIG_fail;
4582     {
4583         arg2 = wxString_in_helper(obj1);
4584         if (arg2 == NULL) SWIG_fail;
4585         temp2 = true;
4586     }
4587     {
4588         PyThreadState* __tstate = wxPyBeginAllowThreads();
4589         (arg1)->SetValue((wxString const &)*arg2);
4590
4591         wxPyEndAllowThreads(__tstate);
4592         if (PyErr_Occurred()) SWIG_fail;
4593     }
4594     Py_INCREF(Py_None); resultobj = Py_None;
4595     {
4596         if (temp2)
4597         delete arg2;
4598     }
4599     return resultobj;
4600     fail:
4601     {
4602         if (temp2)
4603         delete arg2;
4604     }
4605     return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_ComboBox_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
4610     PyObject *resultobj;
4611     wxComboBox *arg1 = (wxComboBox *) 0 ;
4612     PyObject * obj0 = 0 ;
4613     char *kwnames[] = {
4614         (char *) "self", NULL
4615     };
4616
4617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Copy",kwnames,&obj0)) goto fail;
4618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4619     if (SWIG_arg_fail(1)) SWIG_fail;
4620     {
4621         PyThreadState* __tstate = wxPyBeginAllowThreads();
4622         (arg1)->Copy();
4623
4624         wxPyEndAllowThreads(__tstate);
4625         if (PyErr_Occurred()) SWIG_fail;
4626     }
4627     Py_INCREF(Py_None); resultobj = Py_None;
4628     return resultobj;
4629     fail:
4630     return NULL;
4631 }
4632
4633
4634 static PyObject *_wrap_ComboBox_Cut(PyObject *, PyObject *args, PyObject *kwargs) {
4635     PyObject *resultobj;
4636     wxComboBox *arg1 = (wxComboBox *) 0 ;
4637     PyObject * obj0 = 0 ;
4638     char *kwnames[] = {
4639         (char *) "self", NULL
4640     };
4641
4642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Cut",kwnames,&obj0)) goto fail;
4643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4644     if (SWIG_arg_fail(1)) SWIG_fail;
4645     {
4646         PyThreadState* __tstate = wxPyBeginAllowThreads();
4647         (arg1)->Cut();
4648
4649         wxPyEndAllowThreads(__tstate);
4650         if (PyErr_Occurred()) SWIG_fail;
4651     }
4652     Py_INCREF(Py_None); resultobj = Py_None;
4653     return resultobj;
4654     fail:
4655     return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_ComboBox_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
4660     PyObject *resultobj;
4661     wxComboBox *arg1 = (wxComboBox *) 0 ;
4662     PyObject * obj0 = 0 ;
4663     char *kwnames[] = {
4664         (char *) "self", NULL
4665     };
4666
4667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Paste",kwnames,&obj0)) goto fail;
4668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4669     if (SWIG_arg_fail(1)) SWIG_fail;
4670     {
4671         PyThreadState* __tstate = wxPyBeginAllowThreads();
4672         (arg1)->Paste();
4673
4674         wxPyEndAllowThreads(__tstate);
4675         if (PyErr_Occurred()) SWIG_fail;
4676     }
4677     Py_INCREF(Py_None); resultobj = Py_None;
4678     return resultobj;
4679     fail:
4680     return NULL;
4681 }
4682
4683
4684 static PyObject *_wrap_ComboBox_SetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4685     PyObject *resultobj;
4686     wxComboBox *arg1 = (wxComboBox *) 0 ;
4687     long arg2 ;
4688     PyObject * obj0 = 0 ;
4689     PyObject * obj1 = 0 ;
4690     char *kwnames[] = {
4691         (char *) "self",(char *) "pos", NULL
4692     };
4693
4694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetInsertionPoint",kwnames,&obj0,&obj1)) goto fail;
4695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4696     if (SWIG_arg_fail(1)) SWIG_fail;
4697     {
4698         arg2 = (long)(SWIG_As_long(obj1));
4699         if (SWIG_arg_fail(2)) SWIG_fail;
4700     }
4701     {
4702         PyThreadState* __tstate = wxPyBeginAllowThreads();
4703         (arg1)->SetInsertionPoint(arg2);
4704
4705         wxPyEndAllowThreads(__tstate);
4706         if (PyErr_Occurred()) SWIG_fail;
4707     }
4708     Py_INCREF(Py_None); resultobj = Py_None;
4709     return resultobj;
4710     fail:
4711     return NULL;
4712 }
4713
4714
4715 static PyObject *_wrap_ComboBox_GetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4716     PyObject *resultobj;
4717     wxComboBox *arg1 = (wxComboBox *) 0 ;
4718     long result;
4719     PyObject * obj0 = 0 ;
4720     char *kwnames[] = {
4721         (char *) "self", NULL
4722     };
4723
4724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetInsertionPoint",kwnames,&obj0)) goto fail;
4725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4726     if (SWIG_arg_fail(1)) SWIG_fail;
4727     {
4728         PyThreadState* __tstate = wxPyBeginAllowThreads();
4729         result = (long)((wxComboBox const *)arg1)->GetInsertionPoint();
4730
4731         wxPyEndAllowThreads(__tstate);
4732         if (PyErr_Occurred()) SWIG_fail;
4733     }
4734     {
4735         resultobj = SWIG_From_long((long)(result));
4736     }
4737     return resultobj;
4738     fail:
4739     return NULL;
4740 }
4741
4742
4743 static PyObject *_wrap_ComboBox_GetLastPosition(PyObject *, PyObject *args, PyObject *kwargs) {
4744     PyObject *resultobj;
4745     wxComboBox *arg1 = (wxComboBox *) 0 ;
4746     long result;
4747     PyObject * obj0 = 0 ;
4748     char *kwnames[] = {
4749         (char *) "self", NULL
4750     };
4751
4752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetLastPosition",kwnames,&obj0)) goto fail;
4753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4754     if (SWIG_arg_fail(1)) SWIG_fail;
4755     {
4756         PyThreadState* __tstate = wxPyBeginAllowThreads();
4757         result = (long)((wxComboBox const *)arg1)->GetLastPosition();
4758
4759         wxPyEndAllowThreads(__tstate);
4760         if (PyErr_Occurred()) SWIG_fail;
4761     }
4762     {
4763         resultobj = SWIG_From_long((long)(result));
4764     }
4765     return resultobj;
4766     fail:
4767     return NULL;
4768 }
4769
4770
4771 static PyObject *_wrap_ComboBox_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
4772     PyObject *resultobj;
4773     wxComboBox *arg1 = (wxComboBox *) 0 ;
4774     long arg2 ;
4775     long arg3 ;
4776     wxString *arg4 = 0 ;
4777     bool temp4 = false ;
4778     PyObject * obj0 = 0 ;
4779     PyObject * obj1 = 0 ;
4780     PyObject * obj2 = 0 ;
4781     PyObject * obj3 = 0 ;
4782     char *kwnames[] = {
4783         (char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL
4784     };
4785
4786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ComboBox_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4788     if (SWIG_arg_fail(1)) SWIG_fail;
4789     {
4790         arg2 = (long)(SWIG_As_long(obj1));
4791         if (SWIG_arg_fail(2)) SWIG_fail;
4792     }
4793     {
4794         arg3 = (long)(SWIG_As_long(obj2));
4795         if (SWIG_arg_fail(3)) SWIG_fail;
4796     }
4797     {
4798         arg4 = wxString_in_helper(obj3);
4799         if (arg4 == NULL) SWIG_fail;
4800         temp4 = true;
4801     }
4802     {
4803         PyThreadState* __tstate = wxPyBeginAllowThreads();
4804         (arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
4805
4806         wxPyEndAllowThreads(__tstate);
4807         if (PyErr_Occurred()) SWIG_fail;
4808     }
4809     Py_INCREF(Py_None); resultobj = Py_None;
4810     {
4811         if (temp4)
4812         delete arg4;
4813     }
4814     return resultobj;
4815     fail:
4816     {
4817         if (temp4)
4818         delete arg4;
4819     }
4820     return NULL;
4821 }
4822
4823
4824 static PyObject *_wrap_ComboBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4825     PyObject *resultobj;
4826     wxComboBox *arg1 = (wxComboBox *) 0 ;
4827     int arg2 ;
4828     PyObject * obj0 = 0 ;
4829     PyObject * obj1 = 0 ;
4830     char *kwnames[] = {
4831         (char *) "self",(char *) "n", NULL
4832     };
4833
4834     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
4835     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4836     if (SWIG_arg_fail(1)) SWIG_fail;
4837     {
4838         arg2 = (int)(SWIG_As_int(obj1));
4839         if (SWIG_arg_fail(2)) SWIG_fail;
4840     }
4841     {
4842         PyThreadState* __tstate = wxPyBeginAllowThreads();
4843         (arg1)->SetSelection(arg2);
4844
4845         wxPyEndAllowThreads(__tstate);
4846         if (PyErr_Occurred()) SWIG_fail;
4847     }
4848     Py_INCREF(Py_None); resultobj = Py_None;
4849     return resultobj;
4850     fail:
4851     return NULL;
4852 }
4853
4854
4855 static PyObject *_wrap_ComboBox_SetMark(PyObject *, PyObject *args, PyObject *kwargs) {
4856     PyObject *resultobj;
4857     wxComboBox *arg1 = (wxComboBox *) 0 ;
4858     long arg2 ;
4859     long arg3 ;
4860     PyObject * obj0 = 0 ;
4861     PyObject * obj1 = 0 ;
4862     PyObject * obj2 = 0 ;
4863     char *kwnames[] = {
4864         (char *) "self",(char *) "from",(char *) "to", NULL
4865     };
4866
4867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_SetMark",kwnames,&obj0,&obj1,&obj2)) goto fail;
4868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4869     if (SWIG_arg_fail(1)) SWIG_fail;
4870     {
4871         arg2 = (long)(SWIG_As_long(obj1));
4872         if (SWIG_arg_fail(2)) SWIG_fail;
4873     }
4874     {
4875         arg3 = (long)(SWIG_As_long(obj2));
4876         if (SWIG_arg_fail(3)) SWIG_fail;
4877     }
4878     {
4879         PyThreadState* __tstate = wxPyBeginAllowThreads();
4880         (arg1)->SetSelection(arg2,arg3);
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_ComboBox_GetMark(PyObject *, PyObject *args, PyObject *kwargs) {
4893     PyObject *resultobj;
4894     wxComboBox *arg1 = (wxComboBox *) 0 ;
4895     long *arg2 = (long *) 0 ;
4896     long *arg3 = (long *) 0 ;
4897     long temp2 ;
4898     int res2 = 0 ;
4899     long temp3 ;
4900     int res3 = 0 ;
4901     PyObject * obj0 = 0 ;
4902     char *kwnames[] = {
4903         (char *) "self", NULL
4904     };
4905
4906     arg2 = &temp2; res2 = SWIG_NEWOBJ;
4907     arg3 = &temp3; res3 = SWIG_NEWOBJ;
4908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetMark",kwnames,&obj0)) goto fail;
4909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4910     if (SWIG_arg_fail(1)) SWIG_fail;
4911     {
4912         PyThreadState* __tstate = wxPyBeginAllowThreads();
4913         (arg1)->GetSelection(arg2,arg3);
4914
4915         wxPyEndAllowThreads(__tstate);
4916         if (PyErr_Occurred()) SWIG_fail;
4917     }
4918     Py_INCREF(Py_None); resultobj = Py_None;
4919     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4920     SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
4921     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
4922     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
4923     return resultobj;
4924     fail:
4925     return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_ComboBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4930     PyObject *resultobj;
4931     wxComboBox *arg1 = (wxComboBox *) 0 ;
4932     wxString *arg2 = 0 ;
4933     bool result;
4934     bool temp2 = false ;
4935     PyObject * obj0 = 0 ;
4936     PyObject * obj1 = 0 ;
4937     char *kwnames[] = {
4938         (char *) "self",(char *) "string", NULL
4939     };
4940
4941     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
4942     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4943     if (SWIG_arg_fail(1)) SWIG_fail;
4944     {
4945         arg2 = wxString_in_helper(obj1);
4946         if (arg2 == NULL) SWIG_fail;
4947         temp2 = true;
4948     }
4949     {
4950         PyThreadState* __tstate = wxPyBeginAllowThreads();
4951         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
4952
4953         wxPyEndAllowThreads(__tstate);
4954         if (PyErr_Occurred()) SWIG_fail;
4955     }
4956     {
4957         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4958     }
4959     {
4960         if (temp2)
4961         delete arg2;
4962     }
4963     return resultobj;
4964     fail:
4965     {
4966         if (temp2)
4967         delete arg2;
4968     }
4969     return NULL;
4970 }
4971
4972
4973 static PyObject *_wrap_ComboBox_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
4974     PyObject *resultobj;
4975     wxComboBox *arg1 = (wxComboBox *) 0 ;
4976     int arg2 ;
4977     wxString *arg3 = 0 ;
4978     bool temp3 = false ;
4979     PyObject * obj0 = 0 ;
4980     PyObject * obj1 = 0 ;
4981     PyObject * obj2 = 0 ;
4982     char *kwnames[] = {
4983         (char *) "self",(char *) "n",(char *) "string", NULL
4984     };
4985
4986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
4987     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4988     if (SWIG_arg_fail(1)) SWIG_fail;
4989     {
4990         arg2 = (int)(SWIG_As_int(obj1));
4991         if (SWIG_arg_fail(2)) SWIG_fail;
4992     }
4993     {
4994         arg3 = wxString_in_helper(obj2);
4995         if (arg3 == NULL) SWIG_fail;
4996         temp3 = true;
4997     }
4998     {
4999         PyThreadState* __tstate = wxPyBeginAllowThreads();
5000         (arg1)->SetString(arg2,(wxString const &)*arg3);
5001
5002         wxPyEndAllowThreads(__tstate);
5003         if (PyErr_Occurred()) SWIG_fail;
5004     }
5005     Py_INCREF(Py_None); resultobj = Py_None;
5006     {
5007         if (temp3)
5008         delete arg3;
5009     }
5010     return resultobj;
5011     fail:
5012     {
5013         if (temp3)
5014         delete arg3;
5015     }
5016     return NULL;
5017 }
5018
5019
5020 static PyObject *_wrap_ComboBox_SetEditable(PyObject *, PyObject *args, PyObject *kwargs) {
5021     PyObject *resultobj;
5022     wxComboBox *arg1 = (wxComboBox *) 0 ;
5023     bool arg2 ;
5024     PyObject * obj0 = 0 ;
5025     PyObject * obj1 = 0 ;
5026     char *kwnames[] = {
5027         (char *) "self",(char *) "editable", NULL
5028     };
5029
5030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetEditable",kwnames,&obj0,&obj1)) goto fail;
5031     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5032     if (SWIG_arg_fail(1)) SWIG_fail;
5033     {
5034         arg2 = (bool)(SWIG_As_bool(obj1));
5035         if (SWIG_arg_fail(2)) SWIG_fail;
5036     }
5037     {
5038         PyThreadState* __tstate = wxPyBeginAllowThreads();
5039         (arg1)->SetEditable(arg2);
5040
5041         wxPyEndAllowThreads(__tstate);
5042         if (PyErr_Occurred()) SWIG_fail;
5043     }
5044     Py_INCREF(Py_None); resultobj = Py_None;
5045     return resultobj;
5046     fail:
5047     return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_ComboBox_SetInsertionPointEnd(PyObject *, PyObject *args, PyObject *kwargs) {
5052     PyObject *resultobj;
5053     wxComboBox *arg1 = (wxComboBox *) 0 ;
5054     PyObject * obj0 = 0 ;
5055     char *kwnames[] = {
5056         (char *) "self", NULL
5057     };
5058
5059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_SetInsertionPointEnd",kwnames,&obj0)) goto fail;
5060     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5061     if (SWIG_arg_fail(1)) SWIG_fail;
5062     {
5063         PyThreadState* __tstate = wxPyBeginAllowThreads();
5064         (arg1)->SetInsertionPointEnd();
5065
5066         wxPyEndAllowThreads(__tstate);
5067         if (PyErr_Occurred()) SWIG_fail;
5068     }
5069     Py_INCREF(Py_None); resultobj = Py_None;
5070     return resultobj;
5071     fail:
5072     return NULL;
5073 }
5074
5075
5076 static PyObject *_wrap_ComboBox_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
5077     PyObject *resultobj;
5078     wxComboBox *arg1 = (wxComboBox *) 0 ;
5079     long arg2 ;
5080     long arg3 ;
5081     PyObject * obj0 = 0 ;
5082     PyObject * obj1 = 0 ;
5083     PyObject * obj2 = 0 ;
5084     char *kwnames[] = {
5085         (char *) "self",(char *) "from",(char *) "to", NULL
5086     };
5087
5088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_Remove",kwnames,&obj0,&obj1,&obj2)) goto fail;
5089     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5090     if (SWIG_arg_fail(1)) SWIG_fail;
5091     {
5092         arg2 = (long)(SWIG_As_long(obj1));
5093         if (SWIG_arg_fail(2)) SWIG_fail;
5094     }
5095     {
5096         arg3 = (long)(SWIG_As_long(obj2));
5097         if (SWIG_arg_fail(3)) SWIG_fail;
5098     }
5099     {
5100         PyThreadState* __tstate = wxPyBeginAllowThreads();
5101         (arg1)->Remove(arg2,arg3);
5102
5103         wxPyEndAllowThreads(__tstate);
5104         if (PyErr_Occurred()) SWIG_fail;
5105     }
5106     Py_INCREF(Py_None); resultobj = Py_None;
5107     return resultobj;
5108     fail:
5109     return NULL;
5110 }
5111
5112
5113 static PyObject *_wrap_ComboBox_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
5114     PyObject *resultobj;
5115     wxComboBox *arg1 = (wxComboBox *) 0 ;
5116     bool result;
5117     PyObject * obj0 = 0 ;
5118     char *kwnames[] = {
5119         (char *) "self", NULL
5120     };
5121
5122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_IsEditable",kwnames,&obj0)) goto fail;
5123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5124     if (SWIG_arg_fail(1)) SWIG_fail;
5125     {
5126         PyThreadState* __tstate = wxPyBeginAllowThreads();
5127         result = (bool)((wxComboBox const *)arg1)->IsEditable();
5128
5129         wxPyEndAllowThreads(__tstate);
5130         if (PyErr_Occurred()) SWIG_fail;
5131     }
5132     {
5133         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5134     }
5135     return resultobj;
5136     fail:
5137     return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_ComboBox_Undo(PyObject *, PyObject *args, PyObject *kwargs) {
5142     PyObject *resultobj;
5143     wxComboBox *arg1 = (wxComboBox *) 0 ;
5144     PyObject * obj0 = 0 ;
5145     char *kwnames[] = {
5146         (char *) "self", NULL
5147     };
5148
5149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Undo",kwnames,&obj0)) goto fail;
5150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5151     if (SWIG_arg_fail(1)) SWIG_fail;
5152     {
5153         PyThreadState* __tstate = wxPyBeginAllowThreads();
5154         (arg1)->Undo();
5155
5156         wxPyEndAllowThreads(__tstate);
5157         if (PyErr_Occurred()) SWIG_fail;
5158     }
5159     Py_INCREF(Py_None); resultobj = Py_None;
5160     return resultobj;
5161     fail:
5162     return NULL;
5163 }
5164
5165
5166 static PyObject *_wrap_ComboBox_Redo(PyObject *, PyObject *args, PyObject *kwargs) {
5167     PyObject *resultobj;
5168     wxComboBox *arg1 = (wxComboBox *) 0 ;
5169     PyObject * obj0 = 0 ;
5170     char *kwnames[] = {
5171         (char *) "self", NULL
5172     };
5173
5174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Redo",kwnames,&obj0)) goto fail;
5175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5176     if (SWIG_arg_fail(1)) SWIG_fail;
5177     {
5178         PyThreadState* __tstate = wxPyBeginAllowThreads();
5179         (arg1)->Redo();
5180
5181         wxPyEndAllowThreads(__tstate);
5182         if (PyErr_Occurred()) SWIG_fail;
5183     }
5184     Py_INCREF(Py_None); resultobj = Py_None;
5185     return resultobj;
5186     fail:
5187     return NULL;
5188 }
5189
5190
5191 static PyObject *_wrap_ComboBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
5192     PyObject *resultobj;
5193     wxComboBox *arg1 = (wxComboBox *) 0 ;
5194     PyObject * obj0 = 0 ;
5195     char *kwnames[] = {
5196         (char *) "self", NULL
5197     };
5198
5199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_SelectAll",kwnames,&obj0)) goto fail;
5200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5201     if (SWIG_arg_fail(1)) SWIG_fail;
5202     {
5203         PyThreadState* __tstate = wxPyBeginAllowThreads();
5204         (arg1)->SelectAll();
5205
5206         wxPyEndAllowThreads(__tstate);
5207         if (PyErr_Occurred()) SWIG_fail;
5208     }
5209     Py_INCREF(Py_None); resultobj = Py_None;
5210     return resultobj;
5211     fail:
5212     return NULL;
5213 }
5214
5215
5216 static PyObject *_wrap_ComboBox_CanCopy(PyObject *, PyObject *args, PyObject *kwargs) {
5217     PyObject *resultobj;
5218     wxComboBox *arg1 = (wxComboBox *) 0 ;
5219     bool result;
5220     PyObject * obj0 = 0 ;
5221     char *kwnames[] = {
5222         (char *) "self", NULL
5223     };
5224
5225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanCopy",kwnames,&obj0)) goto fail;
5226     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5227     if (SWIG_arg_fail(1)) SWIG_fail;
5228     {
5229         PyThreadState* __tstate = wxPyBeginAllowThreads();
5230         result = (bool)((wxComboBox const *)arg1)->CanCopy();
5231
5232         wxPyEndAllowThreads(__tstate);
5233         if (PyErr_Occurred()) SWIG_fail;
5234     }
5235     {
5236         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5237     }
5238     return resultobj;
5239     fail:
5240     return NULL;
5241 }
5242
5243
5244 static PyObject *_wrap_ComboBox_CanCut(PyObject *, PyObject *args, PyObject *kwargs) {
5245     PyObject *resultobj;
5246     wxComboBox *arg1 = (wxComboBox *) 0 ;
5247     bool result;
5248     PyObject * obj0 = 0 ;
5249     char *kwnames[] = {
5250         (char *) "self", NULL
5251     };
5252
5253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanCut",kwnames,&obj0)) goto fail;
5254     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5255     if (SWIG_arg_fail(1)) SWIG_fail;
5256     {
5257         PyThreadState* __tstate = wxPyBeginAllowThreads();
5258         result = (bool)((wxComboBox const *)arg1)->CanCut();
5259
5260         wxPyEndAllowThreads(__tstate);
5261         if (PyErr_Occurred()) SWIG_fail;
5262     }
5263     {
5264         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5265     }
5266     return resultobj;
5267     fail:
5268     return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_ComboBox_CanPaste(PyObject *, PyObject *args, PyObject *kwargs) {
5273     PyObject *resultobj;
5274     wxComboBox *arg1 = (wxComboBox *) 0 ;
5275     bool result;
5276     PyObject * obj0 = 0 ;
5277     char *kwnames[] = {
5278         (char *) "self", NULL
5279     };
5280
5281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanPaste",kwnames,&obj0)) goto fail;
5282     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5283     if (SWIG_arg_fail(1)) SWIG_fail;
5284     {
5285         PyThreadState* __tstate = wxPyBeginAllowThreads();
5286         result = (bool)((wxComboBox const *)arg1)->CanPaste();
5287
5288         wxPyEndAllowThreads(__tstate);
5289         if (PyErr_Occurred()) SWIG_fail;
5290     }
5291     {
5292         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5293     }
5294     return resultobj;
5295     fail:
5296     return NULL;
5297 }
5298
5299
5300 static PyObject *_wrap_ComboBox_CanUndo(PyObject *, PyObject *args, PyObject *kwargs) {
5301     PyObject *resultobj;
5302     wxComboBox *arg1 = (wxComboBox *) 0 ;
5303     bool result;
5304     PyObject * obj0 = 0 ;
5305     char *kwnames[] = {
5306         (char *) "self", NULL
5307     };
5308
5309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanUndo",kwnames,&obj0)) goto fail;
5310     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5311     if (SWIG_arg_fail(1)) SWIG_fail;
5312     {
5313         PyThreadState* __tstate = wxPyBeginAllowThreads();
5314         result = (bool)((wxComboBox const *)arg1)->CanUndo();
5315
5316         wxPyEndAllowThreads(__tstate);
5317         if (PyErr_Occurred()) SWIG_fail;
5318     }
5319     {
5320         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5321     }
5322     return resultobj;
5323     fail:
5324     return NULL;
5325 }
5326
5327
5328 static PyObject *_wrap_ComboBox_CanRedo(PyObject *, PyObject *args, PyObject *kwargs) {
5329     PyObject *resultobj;
5330     wxComboBox *arg1 = (wxComboBox *) 0 ;
5331     bool result;
5332     PyObject * obj0 = 0 ;
5333     char *kwnames[] = {
5334         (char *) "self", NULL
5335     };
5336
5337     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanRedo",kwnames,&obj0)) goto fail;
5338     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5339     if (SWIG_arg_fail(1)) SWIG_fail;
5340     {
5341         PyThreadState* __tstate = wxPyBeginAllowThreads();
5342         result = (bool)((wxComboBox const *)arg1)->CanRedo();
5343
5344         wxPyEndAllowThreads(__tstate);
5345         if (PyErr_Occurred()) SWIG_fail;
5346     }
5347     {
5348         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5349     }
5350     return resultobj;
5351     fail:
5352     return NULL;
5353 }
5354
5355
5356 static PyObject *_wrap_ComboBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5357     PyObject *resultobj;
5358     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5359     wxVisualAttributes result;
5360     PyObject * obj0 = 0 ;
5361     char *kwnames[] = {
5362         (char *) "variant", NULL
5363     };
5364
5365     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ComboBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5366     if (obj0) {
5367         {
5368             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5369             if (SWIG_arg_fail(1)) SWIG_fail;
5370         }
5371     }
5372     {
5373         if (!wxPyCheckForApp()) SWIG_fail;
5374         PyThreadState* __tstate = wxPyBeginAllowThreads();
5375         result = wxComboBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
5376
5377         wxPyEndAllowThreads(__tstate);
5378         if (PyErr_Occurred()) SWIG_fail;
5379     }
5380     {
5381         wxVisualAttributes * resultptr;
5382         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5383         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5384     }
5385     return resultobj;
5386     fail:
5387     return NULL;
5388 }
5389
5390
5391 static PyObject * ComboBox_swigregister(PyObject *, PyObject *args) {
5392     PyObject *obj;
5393     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5394     SWIG_TypeClientData(SWIGTYPE_p_wxComboBox, obj);
5395     Py_INCREF(obj);
5396     return Py_BuildValue((char *)"");
5397 }
5398 static int _wrap_GaugeNameStr_set(PyObject *) {
5399     PyErr_SetString(PyExc_TypeError,"Variable GaugeNameStr is read-only.");
5400     return 1;
5401 }
5402
5403
5404 static PyObject *_wrap_GaugeNameStr_get(void) {
5405     PyObject *pyobj;
5406
5407     {
5408 #if wxUSE_UNICODE
5409         pyobj = PyUnicode_FromWideChar((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
5410 #else
5411         pyobj = PyString_FromStringAndSize((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
5412 #endif
5413     }
5414     return pyobj;
5415 }
5416
5417
5418 static PyObject *_wrap_new_Gauge(PyObject *, PyObject *args, PyObject *kwargs) {
5419     PyObject *resultobj;
5420     wxWindow *arg1 = (wxWindow *) 0 ;
5421     int arg2 = (int) -1 ;
5422     int arg3 = (int) 100 ;
5423     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5424     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5425     wxSize const &arg5_defvalue = wxDefaultSize ;
5426     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5427     long arg6 = (long) wxGA_HORIZONTAL ;
5428     wxValidator const &arg7_defvalue = wxDefaultValidator ;
5429     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
5430     wxString const &arg8_defvalue = wxPyGaugeNameStr ;
5431     wxString *arg8 = (wxString *) &arg8_defvalue ;
5432     wxGauge *result;
5433     wxPoint temp4 ;
5434     wxSize temp5 ;
5435     bool temp8 = false ;
5436     PyObject * obj0 = 0 ;
5437     PyObject * obj1 = 0 ;
5438     PyObject * obj2 = 0 ;
5439     PyObject * obj3 = 0 ;
5440     PyObject * obj4 = 0 ;
5441     PyObject * obj5 = 0 ;
5442     PyObject * obj6 = 0 ;
5443     PyObject * obj7 = 0 ;
5444     char *kwnames[] = {
5445         (char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
5446     };
5447
5448     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Gauge",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5449     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5450     if (SWIG_arg_fail(1)) SWIG_fail;
5451     if (obj1) {
5452         {
5453             arg2 = (int)(SWIG_As_int(obj1));
5454             if (SWIG_arg_fail(2)) SWIG_fail;
5455         }
5456     }
5457     if (obj2) {
5458         {
5459             arg3 = (int)(SWIG_As_int(obj2));
5460             if (SWIG_arg_fail(3)) SWIG_fail;
5461         }
5462     }
5463     if (obj3) {
5464         {
5465             arg4 = &temp4;
5466             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5467         }
5468     }
5469     if (obj4) {
5470         {
5471             arg5 = &temp5;
5472             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5473         }
5474     }
5475     if (obj5) {
5476         {
5477             arg6 = (long)(SWIG_As_long(obj5));
5478             if (SWIG_arg_fail(6)) SWIG_fail;
5479         }
5480     }
5481     if (obj6) {
5482         {
5483             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
5484             if (SWIG_arg_fail(7)) SWIG_fail;
5485             if (arg7 == NULL) {
5486                 SWIG_null_ref("wxValidator");
5487             }
5488             if (SWIG_arg_fail(7)) SWIG_fail;
5489         }
5490     }
5491     if (obj7) {
5492         {
5493             arg8 = wxString_in_helper(obj7);
5494             if (arg8 == NULL) SWIG_fail;
5495             temp8 = true;
5496         }
5497     }
5498     {
5499         if (!wxPyCheckForApp()) SWIG_fail;
5500         PyThreadState* __tstate = wxPyBeginAllowThreads();
5501         result = (wxGauge *)new wxGauge(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
5502
5503         wxPyEndAllowThreads(__tstate);
5504         if (PyErr_Occurred()) SWIG_fail;
5505     }
5506     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGauge, 1);
5507     {
5508         if (temp8)
5509         delete arg8;
5510     }
5511     return resultobj;
5512     fail:
5513     {
5514         if (temp8)
5515         delete arg8;
5516     }
5517     return NULL;
5518 }
5519
5520
5521 static PyObject *_wrap_new_PreGauge(PyObject *, PyObject *args, PyObject *kwargs) {
5522     PyObject *resultobj;
5523     wxGauge *result;
5524     char *kwnames[] = {
5525         NULL
5526     };
5527
5528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGauge",kwnames)) goto fail;
5529     {
5530         if (!wxPyCheckForApp()) SWIG_fail;
5531         PyThreadState* __tstate = wxPyBeginAllowThreads();
5532         result = (wxGauge *)new wxGauge();
5533
5534         wxPyEndAllowThreads(__tstate);
5535         if (PyErr_Occurred()) SWIG_fail;
5536     }
5537     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGauge, 1);
5538     return resultobj;
5539     fail:
5540     return NULL;
5541 }
5542
5543
5544 static PyObject *_wrap_Gauge_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5545     PyObject *resultobj;
5546     wxGauge *arg1 = (wxGauge *) 0 ;
5547     wxWindow *arg2 = (wxWindow *) 0 ;
5548     int arg3 = (int) -1 ;
5549     int arg4 = (int) 100 ;
5550     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5551     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5552     wxSize const &arg6_defvalue = wxDefaultSize ;
5553     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5554     long arg7 = (long) wxGA_HORIZONTAL ;
5555     wxValidator const &arg8_defvalue = wxDefaultValidator ;
5556     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
5557     wxString const &arg9_defvalue = wxPyGaugeNameStr ;
5558     wxString *arg9 = (wxString *) &arg9_defvalue ;
5559     bool result;
5560     wxPoint temp5 ;
5561     wxSize temp6 ;
5562     bool temp9 = false ;
5563     PyObject * obj0 = 0 ;
5564     PyObject * obj1 = 0 ;
5565     PyObject * obj2 = 0 ;
5566     PyObject * obj3 = 0 ;
5567     PyObject * obj4 = 0 ;
5568     PyObject * obj5 = 0 ;
5569     PyObject * obj6 = 0 ;
5570     PyObject * obj7 = 0 ;
5571     PyObject * obj8 = 0 ;
5572     char *kwnames[] = {
5573         (char *) "self",(char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
5574     };
5575
5576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Gauge_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5578     if (SWIG_arg_fail(1)) SWIG_fail;
5579     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5580     if (SWIG_arg_fail(2)) SWIG_fail;
5581     if (obj2) {
5582         {
5583             arg3 = (int)(SWIG_As_int(obj2));
5584             if (SWIG_arg_fail(3)) SWIG_fail;
5585         }
5586     }
5587     if (obj3) {
5588         {
5589             arg4 = (int)(SWIG_As_int(obj3));
5590             if (SWIG_arg_fail(4)) SWIG_fail;
5591         }
5592     }
5593     if (obj4) {
5594         {
5595             arg5 = &temp5;
5596             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5597         }
5598     }
5599     if (obj5) {
5600         {
5601             arg6 = &temp6;
5602             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5603         }
5604     }
5605     if (obj6) {
5606         {
5607             arg7 = (long)(SWIG_As_long(obj6));
5608             if (SWIG_arg_fail(7)) SWIG_fail;
5609         }
5610     }
5611     if (obj7) {
5612         {
5613             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
5614             if (SWIG_arg_fail(8)) SWIG_fail;
5615             if (arg8 == NULL) {
5616                 SWIG_null_ref("wxValidator");
5617             }
5618             if (SWIG_arg_fail(8)) SWIG_fail;
5619         }
5620     }
5621     if (obj8) {
5622         {
5623             arg9 = wxString_in_helper(obj8);
5624             if (arg9 == NULL) SWIG_fail;
5625             temp9 = true;
5626         }
5627     }
5628     {
5629         PyThreadState* __tstate = wxPyBeginAllowThreads();
5630         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
5631
5632         wxPyEndAllowThreads(__tstate);
5633         if (PyErr_Occurred()) SWIG_fail;
5634     }
5635     {
5636         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5637     }
5638     {
5639         if (temp9)
5640         delete arg9;
5641     }
5642     return resultobj;
5643     fail:
5644     {
5645         if (temp9)
5646         delete arg9;
5647     }
5648     return NULL;
5649 }
5650
5651
5652 static PyObject *_wrap_Gauge_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
5653     PyObject *resultobj;
5654     wxGauge *arg1 = (wxGauge *) 0 ;
5655     int arg2 ;
5656     PyObject * obj0 = 0 ;
5657     PyObject * obj1 = 0 ;
5658     char *kwnames[] = {
5659         (char *) "self",(char *) "range", NULL
5660     };
5661
5662     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetRange",kwnames,&obj0,&obj1)) goto fail;
5663     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5664     if (SWIG_arg_fail(1)) SWIG_fail;
5665     {
5666         arg2 = (int)(SWIG_As_int(obj1));
5667         if (SWIG_arg_fail(2)) SWIG_fail;
5668     }
5669     {
5670         PyThreadState* __tstate = wxPyBeginAllowThreads();
5671         (arg1)->SetRange(arg2);
5672
5673         wxPyEndAllowThreads(__tstate);
5674         if (PyErr_Occurred()) SWIG_fail;
5675     }
5676     Py_INCREF(Py_None); resultobj = Py_None;
5677     return resultobj;
5678     fail:
5679     return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_Gauge_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
5684     PyObject *resultobj;
5685     wxGauge *arg1 = (wxGauge *) 0 ;
5686     int result;
5687     PyObject * obj0 = 0 ;
5688     char *kwnames[] = {
5689         (char *) "self", NULL
5690     };
5691
5692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetRange",kwnames,&obj0)) goto fail;
5693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5694     if (SWIG_arg_fail(1)) SWIG_fail;
5695     {
5696         PyThreadState* __tstate = wxPyBeginAllowThreads();
5697         result = (int)((wxGauge const *)arg1)->GetRange();
5698
5699         wxPyEndAllowThreads(__tstate);
5700         if (PyErr_Occurred()) SWIG_fail;
5701     }
5702     {
5703         resultobj = SWIG_From_int((int)(result));
5704     }
5705     return resultobj;
5706     fail:
5707     return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_Gauge_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5712     PyObject *resultobj;
5713     wxGauge *arg1 = (wxGauge *) 0 ;
5714     int arg2 ;
5715     PyObject * obj0 = 0 ;
5716     PyObject * obj1 = 0 ;
5717     char *kwnames[] = {
5718         (char *) "self",(char *) "pos", NULL
5719     };
5720
5721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetValue",kwnames,&obj0,&obj1)) goto fail;
5722     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5723     if (SWIG_arg_fail(1)) SWIG_fail;
5724     {
5725         arg2 = (int)(SWIG_As_int(obj1));
5726         if (SWIG_arg_fail(2)) SWIG_fail;
5727     }
5728     {
5729         PyThreadState* __tstate = wxPyBeginAllowThreads();
5730         (arg1)->SetValue(arg2);
5731
5732         wxPyEndAllowThreads(__tstate);
5733         if (PyErr_Occurred()) SWIG_fail;
5734     }
5735     Py_INCREF(Py_None); resultobj = Py_None;
5736     return resultobj;
5737     fail:
5738     return NULL;
5739 }
5740
5741
5742 static PyObject *_wrap_Gauge_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5743     PyObject *resultobj;
5744     wxGauge *arg1 = (wxGauge *) 0 ;
5745     int result;
5746     PyObject * obj0 = 0 ;
5747     char *kwnames[] = {
5748         (char *) "self", NULL
5749     };
5750
5751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetValue",kwnames,&obj0)) goto fail;
5752     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5753     if (SWIG_arg_fail(1)) SWIG_fail;
5754     {
5755         PyThreadState* __tstate = wxPyBeginAllowThreads();
5756         result = (int)((wxGauge const *)arg1)->GetValue();
5757
5758         wxPyEndAllowThreads(__tstate);
5759         if (PyErr_Occurred()) SWIG_fail;
5760     }
5761     {
5762         resultobj = SWIG_From_int((int)(result));
5763     }
5764     return resultobj;
5765     fail:
5766     return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_Gauge_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
5771     PyObject *resultobj;
5772     wxGauge *arg1 = (wxGauge *) 0 ;
5773     bool result;
5774     PyObject * obj0 = 0 ;
5775     char *kwnames[] = {
5776         (char *) "self", NULL
5777     };
5778
5779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_IsVertical",kwnames,&obj0)) goto fail;
5780     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5781     if (SWIG_arg_fail(1)) SWIG_fail;
5782     {
5783         PyThreadState* __tstate = wxPyBeginAllowThreads();
5784         result = (bool)((wxGauge const *)arg1)->IsVertical();
5785
5786         wxPyEndAllowThreads(__tstate);
5787         if (PyErr_Occurred()) SWIG_fail;
5788     }
5789     {
5790         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5791     }
5792     return resultobj;
5793     fail:
5794     return NULL;
5795 }
5796
5797
5798 static PyObject *_wrap_Gauge_SetShadowWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5799     PyObject *resultobj;
5800     wxGauge *arg1 = (wxGauge *) 0 ;
5801     int arg2 ;
5802     PyObject * obj0 = 0 ;
5803     PyObject * obj1 = 0 ;
5804     char *kwnames[] = {
5805         (char *) "self",(char *) "w", NULL
5806     };
5807
5808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetShadowWidth",kwnames,&obj0,&obj1)) goto fail;
5809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5810     if (SWIG_arg_fail(1)) SWIG_fail;
5811     {
5812         arg2 = (int)(SWIG_As_int(obj1));
5813         if (SWIG_arg_fail(2)) SWIG_fail;
5814     }
5815     {
5816         PyThreadState* __tstate = wxPyBeginAllowThreads();
5817         (arg1)->SetShadowWidth(arg2);
5818
5819         wxPyEndAllowThreads(__tstate);
5820         if (PyErr_Occurred()) SWIG_fail;
5821     }
5822     Py_INCREF(Py_None); resultobj = Py_None;
5823     return resultobj;
5824     fail:
5825     return NULL;
5826 }
5827
5828
5829 static PyObject *_wrap_Gauge_GetShadowWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5830     PyObject *resultobj;
5831     wxGauge *arg1 = (wxGauge *) 0 ;
5832     int result;
5833     PyObject * obj0 = 0 ;
5834     char *kwnames[] = {
5835         (char *) "self", NULL
5836     };
5837
5838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetShadowWidth",kwnames,&obj0)) goto fail;
5839     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5840     if (SWIG_arg_fail(1)) SWIG_fail;
5841     {
5842         PyThreadState* __tstate = wxPyBeginAllowThreads();
5843         result = (int)((wxGauge const *)arg1)->GetShadowWidth();
5844
5845         wxPyEndAllowThreads(__tstate);
5846         if (PyErr_Occurred()) SWIG_fail;
5847     }
5848     {
5849         resultobj = SWIG_From_int((int)(result));
5850     }
5851     return resultobj;
5852     fail:
5853     return NULL;
5854 }
5855
5856
5857 static PyObject *_wrap_Gauge_SetBezelFace(PyObject *, PyObject *args, PyObject *kwargs) {
5858     PyObject *resultobj;
5859     wxGauge *arg1 = (wxGauge *) 0 ;
5860     int arg2 ;
5861     PyObject * obj0 = 0 ;
5862     PyObject * obj1 = 0 ;
5863     char *kwnames[] = {
5864         (char *) "self",(char *) "w", NULL
5865     };
5866
5867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetBezelFace",kwnames,&obj0,&obj1)) goto fail;
5868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5869     if (SWIG_arg_fail(1)) SWIG_fail;
5870     {
5871         arg2 = (int)(SWIG_As_int(obj1));
5872         if (SWIG_arg_fail(2)) SWIG_fail;
5873     }
5874     {
5875         PyThreadState* __tstate = wxPyBeginAllowThreads();
5876         (arg1)->SetBezelFace(arg2);
5877
5878         wxPyEndAllowThreads(__tstate);
5879         if (PyErr_Occurred()) SWIG_fail;
5880     }
5881     Py_INCREF(Py_None); resultobj = Py_None;
5882     return resultobj;
5883     fail:
5884     return NULL;
5885 }
5886
5887
5888 static PyObject *_wrap_Gauge_GetBezelFace(PyObject *, PyObject *args, PyObject *kwargs) {
5889     PyObject *resultobj;
5890     wxGauge *arg1 = (wxGauge *) 0 ;
5891     int result;
5892     PyObject * obj0 = 0 ;
5893     char *kwnames[] = {
5894         (char *) "self", NULL
5895     };
5896
5897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetBezelFace",kwnames,&obj0)) goto fail;
5898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5899     if (SWIG_arg_fail(1)) SWIG_fail;
5900     {
5901         PyThreadState* __tstate = wxPyBeginAllowThreads();
5902         result = (int)((wxGauge const *)arg1)->GetBezelFace();
5903
5904         wxPyEndAllowThreads(__tstate);
5905         if (PyErr_Occurred()) SWIG_fail;
5906     }
5907     {
5908         resultobj = SWIG_From_int((int)(result));
5909     }
5910     return resultobj;
5911     fail:
5912     return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_Gauge_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5917     PyObject *resultobj;
5918     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5919     wxVisualAttributes result;
5920     PyObject * obj0 = 0 ;
5921     char *kwnames[] = {
5922         (char *) "variant", NULL
5923     };
5924
5925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Gauge_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5926     if (obj0) {
5927         {
5928             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5929             if (SWIG_arg_fail(1)) SWIG_fail;
5930         }
5931     }
5932     {
5933         if (!wxPyCheckForApp()) SWIG_fail;
5934         PyThreadState* __tstate = wxPyBeginAllowThreads();
5935         result = wxGauge::GetClassDefaultAttributes((wxWindowVariant )arg1);
5936
5937         wxPyEndAllowThreads(__tstate);
5938         if (PyErr_Occurred()) SWIG_fail;
5939     }
5940     {
5941         wxVisualAttributes * resultptr;
5942         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5943         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5944     }
5945     return resultobj;
5946     fail:
5947     return NULL;
5948 }
5949
5950
5951 static PyObject * Gauge_swigregister(PyObject *, PyObject *args) {
5952     PyObject *obj;
5953     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5954     SWIG_TypeClientData(SWIGTYPE_p_wxGauge, obj);
5955     Py_INCREF(obj);
5956     return Py_BuildValue((char *)"");
5957 }
5958 static int _wrap_StaticBitmapNameStr_set(PyObject *) {
5959     PyErr_SetString(PyExc_TypeError,"Variable StaticBitmapNameStr is read-only.");
5960     return 1;
5961 }
5962
5963
5964 static PyObject *_wrap_StaticBitmapNameStr_get(void) {
5965     PyObject *pyobj;
5966
5967     {
5968 #if wxUSE_UNICODE
5969         pyobj = PyUnicode_FromWideChar((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
5970 #else
5971         pyobj = PyString_FromStringAndSize((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
5972 #endif
5973     }
5974     return pyobj;
5975 }
5976
5977
5978 static int _wrap_StaticBoxNameStr_set(PyObject *) {
5979     PyErr_SetString(PyExc_TypeError,"Variable StaticBoxNameStr is read-only.");
5980     return 1;
5981 }
5982
5983
5984 static PyObject *_wrap_StaticBoxNameStr_get(void) {
5985     PyObject *pyobj;
5986
5987     {
5988 #if wxUSE_UNICODE
5989         pyobj = PyUnicode_FromWideChar((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
5990 #else
5991         pyobj = PyString_FromStringAndSize((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
5992 #endif
5993     }
5994     return pyobj;
5995 }
5996
5997
5998 static int _wrap_StaticTextNameStr_set(PyObject *) {
5999     PyErr_SetString(PyExc_TypeError,"Variable StaticTextNameStr is read-only.");
6000     return 1;
6001 }
6002
6003
6004 static PyObject *_wrap_StaticTextNameStr_get(void) {
6005     PyObject *pyobj;
6006
6007     {
6008 #if wxUSE_UNICODE
6009         pyobj = PyUnicode_FromWideChar((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
6010 #else
6011         pyobj = PyString_FromStringAndSize((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
6012 #endif
6013     }
6014     return pyobj;
6015 }
6016
6017
6018 static PyObject *_wrap_new_StaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
6019     PyObject *resultobj;
6020     wxWindow *arg1 = (wxWindow *) 0 ;
6021     int arg2 = (int) -1 ;
6022     wxString const &arg3_defvalue = wxPyEmptyString ;
6023     wxString *arg3 = (wxString *) &arg3_defvalue ;
6024     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6025     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6026     wxSize const &arg5_defvalue = wxDefaultSize ;
6027     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6028     long arg6 = (long) 0 ;
6029     wxString const &arg7_defvalue = wxPyStaticBoxNameStr ;
6030     wxString *arg7 = (wxString *) &arg7_defvalue ;
6031     wxStaticBox *result;
6032     bool temp3 = false ;
6033     wxPoint temp4 ;
6034     wxSize temp5 ;
6035     bool temp7 = false ;
6036     PyObject * obj0 = 0 ;
6037     PyObject * obj1 = 0 ;
6038     PyObject * obj2 = 0 ;
6039     PyObject * obj3 = 0 ;
6040     PyObject * obj4 = 0 ;
6041     PyObject * obj5 = 0 ;
6042     PyObject * obj6 = 0 ;
6043     char *kwnames[] = {
6044         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6045     };
6046
6047     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6048     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6049     if (SWIG_arg_fail(1)) SWIG_fail;
6050     if (obj1) {
6051         {
6052             arg2 = (int)(SWIG_As_int(obj1));
6053             if (SWIG_arg_fail(2)) SWIG_fail;
6054         }
6055     }
6056     if (obj2) {
6057         {
6058             arg3 = wxString_in_helper(obj2);
6059             if (arg3 == NULL) SWIG_fail;
6060             temp3 = true;
6061         }
6062     }
6063     if (obj3) {
6064         {
6065             arg4 = &temp4;
6066             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6067         }
6068     }
6069     if (obj4) {
6070         {
6071             arg5 = &temp5;
6072             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6073         }
6074     }
6075     if (obj5) {
6076         {
6077             arg6 = (long)(SWIG_As_long(obj5));
6078             if (SWIG_arg_fail(6)) SWIG_fail;
6079         }
6080     }
6081     if (obj6) {
6082         {
6083             arg7 = wxString_in_helper(obj6);
6084             if (arg7 == NULL) SWIG_fail;
6085             temp7 = true;
6086         }
6087     }
6088     {
6089         if (!wxPyCheckForApp()) SWIG_fail;
6090         PyThreadState* __tstate = wxPyBeginAllowThreads();
6091         result = (wxStaticBox *)new wxStaticBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6092
6093         wxPyEndAllowThreads(__tstate);
6094         if (PyErr_Occurred()) SWIG_fail;
6095     }
6096     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBox, 1);
6097     {
6098         if (temp3)
6099         delete arg3;
6100     }
6101     {
6102         if (temp7)
6103         delete arg7;
6104     }
6105     return resultobj;
6106     fail:
6107     {
6108         if (temp3)
6109         delete arg3;
6110     }
6111     {
6112         if (temp7)
6113         delete arg7;
6114     }
6115     return NULL;
6116 }
6117
6118
6119 static PyObject *_wrap_new_PreStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
6120     PyObject *resultobj;
6121     wxStaticBox *result;
6122     char *kwnames[] = {
6123         NULL
6124     };
6125
6126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticBox",kwnames)) goto fail;
6127     {
6128         if (!wxPyCheckForApp()) SWIG_fail;
6129         PyThreadState* __tstate = wxPyBeginAllowThreads();
6130         result = (wxStaticBox *)new wxStaticBox();
6131
6132         wxPyEndAllowThreads(__tstate);
6133         if (PyErr_Occurred()) SWIG_fail;
6134     }
6135     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBox, 1);
6136     return resultobj;
6137     fail:
6138     return NULL;
6139 }
6140
6141
6142 static PyObject *_wrap_StaticBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6143     PyObject *resultobj;
6144     wxStaticBox *arg1 = (wxStaticBox *) 0 ;
6145     wxWindow *arg2 = (wxWindow *) 0 ;
6146     int arg3 = (int) -1 ;
6147     wxString const &arg4_defvalue = wxPyEmptyString ;
6148     wxString *arg4 = (wxString *) &arg4_defvalue ;
6149     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6150     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6151     wxSize const &arg6_defvalue = wxDefaultSize ;
6152     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6153     long arg7 = (long) 0 ;
6154     wxString const &arg8_defvalue = wxPyStaticBoxNameStr ;
6155     wxString *arg8 = (wxString *) &arg8_defvalue ;
6156     bool result;
6157     bool temp4 = false ;
6158     wxPoint temp5 ;
6159     wxSize temp6 ;
6160     bool temp8 = false ;
6161     PyObject * obj0 = 0 ;
6162     PyObject * obj1 = 0 ;
6163     PyObject * obj2 = 0 ;
6164     PyObject * obj3 = 0 ;
6165     PyObject * obj4 = 0 ;
6166     PyObject * obj5 = 0 ;
6167     PyObject * obj6 = 0 ;
6168     PyObject * obj7 = 0 ;
6169     char *kwnames[] = {
6170         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6171     };
6172
6173     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6174     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
6175     if (SWIG_arg_fail(1)) SWIG_fail;
6176     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6177     if (SWIG_arg_fail(2)) SWIG_fail;
6178     if (obj2) {
6179         {
6180             arg3 = (int)(SWIG_As_int(obj2));
6181             if (SWIG_arg_fail(3)) SWIG_fail;
6182         }
6183     }
6184     if (obj3) {
6185         {
6186             arg4 = wxString_in_helper(obj3);
6187             if (arg4 == NULL) SWIG_fail;
6188             temp4 = true;
6189         }
6190     }
6191     if (obj4) {
6192         {
6193             arg5 = &temp5;
6194             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6195         }
6196     }
6197     if (obj5) {
6198         {
6199             arg6 = &temp6;
6200             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6201         }
6202     }
6203     if (obj6) {
6204         {
6205             arg7 = (long)(SWIG_As_long(obj6));
6206             if (SWIG_arg_fail(7)) SWIG_fail;
6207         }
6208     }
6209     if (obj7) {
6210         {
6211             arg8 = wxString_in_helper(obj7);
6212             if (arg8 == NULL) SWIG_fail;
6213             temp8 = true;
6214         }
6215     }
6216     {
6217         PyThreadState* __tstate = wxPyBeginAllowThreads();
6218         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6219
6220         wxPyEndAllowThreads(__tstate);
6221         if (PyErr_Occurred()) SWIG_fail;
6222     }
6223     {
6224         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6225     }
6226     {
6227         if (temp4)
6228         delete arg4;
6229     }
6230     {
6231         if (temp8)
6232         delete arg8;
6233     }
6234     return resultobj;
6235     fail:
6236     {
6237         if (temp4)
6238         delete arg4;
6239     }
6240     {
6241         if (temp8)
6242         delete arg8;
6243     }
6244     return NULL;
6245 }
6246
6247
6248 static PyObject *_wrap_StaticBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6249     PyObject *resultobj;
6250     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6251     wxVisualAttributes result;
6252     PyObject * obj0 = 0 ;
6253     char *kwnames[] = {
6254         (char *) "variant", NULL
6255     };
6256
6257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6258     if (obj0) {
6259         {
6260             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6261             if (SWIG_arg_fail(1)) SWIG_fail;
6262         }
6263     }
6264     {
6265         if (!wxPyCheckForApp()) SWIG_fail;
6266         PyThreadState* __tstate = wxPyBeginAllowThreads();
6267         result = wxStaticBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
6268
6269         wxPyEndAllowThreads(__tstate);
6270         if (PyErr_Occurred()) SWIG_fail;
6271     }
6272     {
6273         wxVisualAttributes * resultptr;
6274         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6275         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6276     }
6277     return resultobj;
6278     fail:
6279     return NULL;
6280 }
6281
6282
6283 static PyObject * StaticBox_swigregister(PyObject *, PyObject *args) {
6284     PyObject *obj;
6285     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6286     SWIG_TypeClientData(SWIGTYPE_p_wxStaticBox, obj);
6287     Py_INCREF(obj);
6288     return Py_BuildValue((char *)"");
6289 }
6290 static PyObject *_wrap_new_StaticLine(PyObject *, PyObject *args, PyObject *kwargs) {
6291     PyObject *resultobj;
6292     wxWindow *arg1 = (wxWindow *) 0 ;
6293     int arg2 = (int) -1 ;
6294     wxPoint const &arg3_defvalue = wxDefaultPosition ;
6295     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
6296     wxSize const &arg4_defvalue = wxDefaultSize ;
6297     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
6298     long arg5 = (long) wxLI_HORIZONTAL ;
6299     wxString const &arg6_defvalue = wxPyStaticTextNameStr ;
6300     wxString *arg6 = (wxString *) &arg6_defvalue ;
6301     wxStaticLine *result;
6302     wxPoint temp3 ;
6303     wxSize temp4 ;
6304     bool temp6 = false ;
6305     PyObject * obj0 = 0 ;
6306     PyObject * obj1 = 0 ;
6307     PyObject * obj2 = 0 ;
6308     PyObject * obj3 = 0 ;
6309     PyObject * obj4 = 0 ;
6310     PyObject * obj5 = 0 ;
6311     char *kwnames[] = {
6312         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6313     };
6314
6315     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_StaticLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6316     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6317     if (SWIG_arg_fail(1)) SWIG_fail;
6318     if (obj1) {
6319         {
6320             arg2 = (int)(SWIG_As_int(obj1));
6321             if (SWIG_arg_fail(2)) SWIG_fail;
6322         }
6323     }
6324     if (obj2) {
6325         {
6326             arg3 = &temp3;
6327             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
6328         }
6329     }
6330     if (obj3) {
6331         {
6332             arg4 = &temp4;
6333             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
6334         }
6335     }
6336     if (obj4) {
6337         {
6338             arg5 = (long)(SWIG_As_long(obj4));
6339             if (SWIG_arg_fail(5)) SWIG_fail;
6340         }
6341     }
6342     if (obj5) {
6343         {
6344             arg6 = wxString_in_helper(obj5);
6345             if (arg6 == NULL) SWIG_fail;
6346             temp6 = true;
6347         }
6348     }
6349     {
6350         if (!wxPyCheckForApp()) SWIG_fail;
6351         PyThreadState* __tstate = wxPyBeginAllowThreads();
6352         result = (wxStaticLine *)new wxStaticLine(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
6353
6354         wxPyEndAllowThreads(__tstate);
6355         if (PyErr_Occurred()) SWIG_fail;
6356     }
6357     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticLine, 1);
6358     {
6359         if (temp6)
6360         delete arg6;
6361     }
6362     return resultobj;
6363     fail:
6364     {
6365         if (temp6)
6366         delete arg6;
6367     }
6368     return NULL;
6369 }
6370
6371
6372 static PyObject *_wrap_new_PreStaticLine(PyObject *, PyObject *args, PyObject *kwargs) {
6373     PyObject *resultobj;
6374     wxStaticLine *result;
6375     char *kwnames[] = {
6376         NULL
6377     };
6378
6379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticLine",kwnames)) goto fail;
6380     {
6381         if (!wxPyCheckForApp()) SWIG_fail;
6382         PyThreadState* __tstate = wxPyBeginAllowThreads();
6383         result = (wxStaticLine *)new wxStaticLine();
6384
6385         wxPyEndAllowThreads(__tstate);
6386         if (PyErr_Occurred()) SWIG_fail;
6387     }
6388     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticLine, 1);
6389     return resultobj;
6390     fail:
6391     return NULL;
6392 }
6393
6394
6395 static PyObject *_wrap_StaticLine_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6396     PyObject *resultobj;
6397     wxStaticLine *arg1 = (wxStaticLine *) 0 ;
6398     wxWindow *arg2 = (wxWindow *) 0 ;
6399     int arg3 = (int) -1 ;
6400     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6401     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6402     wxSize const &arg5_defvalue = wxDefaultSize ;
6403     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6404     long arg6 = (long) wxLI_HORIZONTAL ;
6405     wxString const &arg7_defvalue = wxPyStaticTextNameStr ;
6406     wxString *arg7 = (wxString *) &arg7_defvalue ;
6407     bool result;
6408     wxPoint temp4 ;
6409     wxSize temp5 ;
6410     bool temp7 = false ;
6411     PyObject * obj0 = 0 ;
6412     PyObject * obj1 = 0 ;
6413     PyObject * obj2 = 0 ;
6414     PyObject * obj3 = 0 ;
6415     PyObject * obj4 = 0 ;
6416     PyObject * obj5 = 0 ;
6417     PyObject * obj6 = 0 ;
6418     char *kwnames[] = {
6419         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6420     };
6421
6422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:StaticLine_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticLine, SWIG_POINTER_EXCEPTION | 0);
6424     if (SWIG_arg_fail(1)) SWIG_fail;
6425     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6426     if (SWIG_arg_fail(2)) SWIG_fail;
6427     if (obj2) {
6428         {
6429             arg3 = (int)(SWIG_As_int(obj2));
6430             if (SWIG_arg_fail(3)) SWIG_fail;
6431         }
6432     }
6433     if (obj3) {
6434         {
6435             arg4 = &temp4;
6436             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6437         }
6438     }
6439     if (obj4) {
6440         {
6441             arg5 = &temp5;
6442             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6443         }
6444     }
6445     if (obj5) {
6446         {
6447             arg6 = (long)(SWIG_As_long(obj5));
6448             if (SWIG_arg_fail(6)) SWIG_fail;
6449         }
6450     }
6451     if (obj6) {
6452         {
6453             arg7 = wxString_in_helper(obj6);
6454             if (arg7 == NULL) SWIG_fail;
6455             temp7 = true;
6456         }
6457     }
6458     {
6459         PyThreadState* __tstate = wxPyBeginAllowThreads();
6460         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6461
6462         wxPyEndAllowThreads(__tstate);
6463         if (PyErr_Occurred()) SWIG_fail;
6464     }
6465     {
6466         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6467     }
6468     {
6469         if (temp7)
6470         delete arg7;
6471     }
6472     return resultobj;
6473     fail:
6474     {
6475         if (temp7)
6476         delete arg7;
6477     }
6478     return NULL;
6479 }
6480
6481
6482 static PyObject *_wrap_StaticLine_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
6483     PyObject *resultobj;
6484     wxStaticLine *arg1 = (wxStaticLine *) 0 ;
6485     bool result;
6486     PyObject * obj0 = 0 ;
6487     char *kwnames[] = {
6488         (char *) "self", NULL
6489     };
6490
6491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticLine_IsVertical",kwnames,&obj0)) goto fail;
6492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticLine, SWIG_POINTER_EXCEPTION | 0);
6493     if (SWIG_arg_fail(1)) SWIG_fail;
6494     {
6495         PyThreadState* __tstate = wxPyBeginAllowThreads();
6496         result = (bool)((wxStaticLine const *)arg1)->IsVertical();
6497
6498         wxPyEndAllowThreads(__tstate);
6499         if (PyErr_Occurred()) SWIG_fail;
6500     }
6501     {
6502         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6503     }
6504     return resultobj;
6505     fail:
6506     return NULL;
6507 }
6508
6509
6510 static PyObject *_wrap_StaticLine_GetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
6511     PyObject *resultobj;
6512     int result;
6513     char *kwnames[] = {
6514         NULL
6515     };
6516
6517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StaticLine_GetDefaultSize",kwnames)) goto fail;
6518     {
6519         PyThreadState* __tstate = wxPyBeginAllowThreads();
6520         result = (int)wxStaticLine::GetDefaultSize();
6521
6522         wxPyEndAllowThreads(__tstate);
6523         if (PyErr_Occurred()) SWIG_fail;
6524     }
6525     {
6526         resultobj = SWIG_From_int((int)(result));
6527     }
6528     return resultobj;
6529     fail:
6530     return NULL;
6531 }
6532
6533
6534 static PyObject *_wrap_StaticLine_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6535     PyObject *resultobj;
6536     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6537     wxVisualAttributes result;
6538     PyObject * obj0 = 0 ;
6539     char *kwnames[] = {
6540         (char *) "variant", NULL
6541     };
6542
6543     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticLine_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6544     if (obj0) {
6545         {
6546             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6547             if (SWIG_arg_fail(1)) SWIG_fail;
6548         }
6549     }
6550     {
6551         if (!wxPyCheckForApp()) SWIG_fail;
6552         PyThreadState* __tstate = wxPyBeginAllowThreads();
6553         result = wxStaticLine::GetClassDefaultAttributes((wxWindowVariant )arg1);
6554
6555         wxPyEndAllowThreads(__tstate);
6556         if (PyErr_Occurred()) SWIG_fail;
6557     }
6558     {
6559         wxVisualAttributes * resultptr;
6560         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6561         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6562     }
6563     return resultobj;
6564     fail:
6565     return NULL;
6566 }
6567
6568
6569 static PyObject * StaticLine_swigregister(PyObject *, PyObject *args) {
6570     PyObject *obj;
6571     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6572     SWIG_TypeClientData(SWIGTYPE_p_wxStaticLine, obj);
6573     Py_INCREF(obj);
6574     return Py_BuildValue((char *)"");
6575 }
6576 static PyObject *_wrap_new_StaticText(PyObject *, PyObject *args, PyObject *kwargs) {
6577     PyObject *resultobj;
6578     wxWindow *arg1 = (wxWindow *) 0 ;
6579     int arg2 = (int) -1 ;
6580     wxString const &arg3_defvalue = wxPyEmptyString ;
6581     wxString *arg3 = (wxString *) &arg3_defvalue ;
6582     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6583     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6584     wxSize const &arg5_defvalue = wxDefaultSize ;
6585     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6586     long arg6 = (long) 0 ;
6587     wxString const &arg7_defvalue = wxPyStaticTextNameStr ;
6588     wxString *arg7 = (wxString *) &arg7_defvalue ;
6589     wxStaticText *result;
6590     bool temp3 = false ;
6591     wxPoint temp4 ;
6592     wxSize temp5 ;
6593     bool temp7 = false ;
6594     PyObject * obj0 = 0 ;
6595     PyObject * obj1 = 0 ;
6596     PyObject * obj2 = 0 ;
6597     PyObject * obj3 = 0 ;
6598     PyObject * obj4 = 0 ;
6599     PyObject * obj5 = 0 ;
6600     PyObject * obj6 = 0 ;
6601     char *kwnames[] = {
6602         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6603     };
6604
6605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6607     if (SWIG_arg_fail(1)) SWIG_fail;
6608     if (obj1) {
6609         {
6610             arg2 = (int)(SWIG_As_int(obj1));
6611             if (SWIG_arg_fail(2)) SWIG_fail;
6612         }
6613     }
6614     if (obj2) {
6615         {
6616             arg3 = wxString_in_helper(obj2);
6617             if (arg3 == NULL) SWIG_fail;
6618             temp3 = true;
6619         }
6620     }
6621     if (obj3) {
6622         {
6623             arg4 = &temp4;
6624             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6625         }
6626     }
6627     if (obj4) {
6628         {
6629             arg5 = &temp5;
6630             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6631         }
6632     }
6633     if (obj5) {
6634         {
6635             arg6 = (long)(SWIG_As_long(obj5));
6636             if (SWIG_arg_fail(6)) SWIG_fail;
6637         }
6638     }
6639     if (obj6) {
6640         {
6641             arg7 = wxString_in_helper(obj6);
6642             if (arg7 == NULL) SWIG_fail;
6643             temp7 = true;
6644         }
6645     }
6646     {
6647         if (!wxPyCheckForApp()) SWIG_fail;
6648         PyThreadState* __tstate = wxPyBeginAllowThreads();
6649         result = (wxStaticText *)new wxStaticText(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6650
6651         wxPyEndAllowThreads(__tstate);
6652         if (PyErr_Occurred()) SWIG_fail;
6653     }
6654     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticText, 1);
6655     {
6656         if (temp3)
6657         delete arg3;
6658     }
6659     {
6660         if (temp7)
6661         delete arg7;
6662     }
6663     return resultobj;
6664     fail:
6665     {
6666         if (temp3)
6667         delete arg3;
6668     }
6669     {
6670         if (temp7)
6671         delete arg7;
6672     }
6673     return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_new_PreStaticText(PyObject *, PyObject *args, PyObject *kwargs) {
6678     PyObject *resultobj;
6679     wxStaticText *result;
6680     char *kwnames[] = {
6681         NULL
6682     };
6683
6684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticText",kwnames)) goto fail;
6685     {
6686         if (!wxPyCheckForApp()) SWIG_fail;
6687         PyThreadState* __tstate = wxPyBeginAllowThreads();
6688         result = (wxStaticText *)new wxStaticText();
6689
6690         wxPyEndAllowThreads(__tstate);
6691         if (PyErr_Occurred()) SWIG_fail;
6692     }
6693     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticText, 1);
6694     return resultobj;
6695     fail:
6696     return NULL;
6697 }
6698
6699
6700 static PyObject *_wrap_StaticText_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6701     PyObject *resultobj;
6702     wxStaticText *arg1 = (wxStaticText *) 0 ;
6703     wxWindow *arg2 = (wxWindow *) 0 ;
6704     int arg3 = (int) -1 ;
6705     wxString const &arg4_defvalue = wxPyEmptyString ;
6706     wxString *arg4 = (wxString *) &arg4_defvalue ;
6707     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6708     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6709     wxSize const &arg6_defvalue = wxDefaultSize ;
6710     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6711     long arg7 = (long) 0 ;
6712     wxString const &arg8_defvalue = wxPyStaticTextNameStr ;
6713     wxString *arg8 = (wxString *) &arg8_defvalue ;
6714     bool result;
6715     bool temp4 = false ;
6716     wxPoint temp5 ;
6717     wxSize temp6 ;
6718     bool temp8 = false ;
6719     PyObject * obj0 = 0 ;
6720     PyObject * obj1 = 0 ;
6721     PyObject * obj2 = 0 ;
6722     PyObject * obj3 = 0 ;
6723     PyObject * obj4 = 0 ;
6724     PyObject * obj5 = 0 ;
6725     PyObject * obj6 = 0 ;
6726     PyObject * obj7 = 0 ;
6727     char *kwnames[] = {
6728         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6729     };
6730
6731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticText_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticText, SWIG_POINTER_EXCEPTION | 0);
6733     if (SWIG_arg_fail(1)) SWIG_fail;
6734     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6735     if (SWIG_arg_fail(2)) SWIG_fail;
6736     if (obj2) {
6737         {
6738             arg3 = (int)(SWIG_As_int(obj2));
6739             if (SWIG_arg_fail(3)) SWIG_fail;
6740         }
6741     }
6742     if (obj3) {
6743         {
6744             arg4 = wxString_in_helper(obj3);
6745             if (arg4 == NULL) SWIG_fail;
6746             temp4 = true;
6747         }
6748     }
6749     if (obj4) {
6750         {
6751             arg5 = &temp5;
6752             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6753         }
6754     }
6755     if (obj5) {
6756         {
6757             arg6 = &temp6;
6758             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6759         }
6760     }
6761     if (obj6) {
6762         {
6763             arg7 = (long)(SWIG_As_long(obj6));
6764             if (SWIG_arg_fail(7)) SWIG_fail;
6765         }
6766     }
6767     if (obj7) {
6768         {
6769             arg8 = wxString_in_helper(obj7);
6770             if (arg8 == NULL) SWIG_fail;
6771             temp8 = true;
6772         }
6773     }
6774     {
6775         PyThreadState* __tstate = wxPyBeginAllowThreads();
6776         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6777
6778         wxPyEndAllowThreads(__tstate);
6779         if (PyErr_Occurred()) SWIG_fail;
6780     }
6781     {
6782         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6783     }
6784     {
6785         if (temp4)
6786         delete arg4;
6787     }
6788     {
6789         if (temp8)
6790         delete arg8;
6791     }
6792     return resultobj;
6793     fail:
6794     {
6795         if (temp4)
6796         delete arg4;
6797     }
6798     {
6799         if (temp8)
6800         delete arg8;
6801     }
6802     return NULL;
6803 }
6804
6805
6806 static PyObject *_wrap_StaticText_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6807     PyObject *resultobj;
6808     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6809     wxVisualAttributes result;
6810     PyObject * obj0 = 0 ;
6811     char *kwnames[] = {
6812         (char *) "variant", NULL
6813     };
6814
6815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticText_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6816     if (obj0) {
6817         {
6818             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6819             if (SWIG_arg_fail(1)) SWIG_fail;
6820         }
6821     }
6822     {
6823         if (!wxPyCheckForApp()) SWIG_fail;
6824         PyThreadState* __tstate = wxPyBeginAllowThreads();
6825         result = wxStaticText::GetClassDefaultAttributes((wxWindowVariant )arg1);
6826
6827         wxPyEndAllowThreads(__tstate);
6828         if (PyErr_Occurred()) SWIG_fail;
6829     }
6830     {
6831         wxVisualAttributes * resultptr;
6832         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6833         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6834     }
6835     return resultobj;
6836     fail:
6837     return NULL;
6838 }
6839
6840
6841 static PyObject * StaticText_swigregister(PyObject *, PyObject *args) {
6842     PyObject *obj;
6843     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6844     SWIG_TypeClientData(SWIGTYPE_p_wxStaticText, obj);
6845     Py_INCREF(obj);
6846     return Py_BuildValue((char *)"");
6847 }
6848 static PyObject *_wrap_new_StaticBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6849     PyObject *resultobj;
6850     wxWindow *arg1 = (wxWindow *) 0 ;
6851     int arg2 = (int) -1 ;
6852     wxBitmap const &arg3_defvalue = wxNullBitmap ;
6853     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
6854     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6855     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6856     wxSize const &arg5_defvalue = wxDefaultSize ;
6857     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6858     long arg6 = (long) 0 ;
6859     wxString const &arg7_defvalue = wxPyStaticBitmapNameStr ;
6860     wxString *arg7 = (wxString *) &arg7_defvalue ;
6861     wxStaticBitmap *result;
6862     wxPoint temp4 ;
6863     wxSize temp5 ;
6864     bool temp7 = false ;
6865     PyObject * obj0 = 0 ;
6866     PyObject * obj1 = 0 ;
6867     PyObject * obj2 = 0 ;
6868     PyObject * obj3 = 0 ;
6869     PyObject * obj4 = 0 ;
6870     PyObject * obj5 = 0 ;
6871     PyObject * obj6 = 0 ;
6872     char *kwnames[] = {
6873         (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6874     };
6875
6876     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6877     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6878     if (SWIG_arg_fail(1)) SWIG_fail;
6879     if (obj1) {
6880         {
6881             arg2 = (int)(SWIG_As_int(obj1));
6882             if (SWIG_arg_fail(2)) SWIG_fail;
6883         }
6884     }
6885     if (obj2) {
6886         {
6887             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6888             if (SWIG_arg_fail(3)) SWIG_fail;
6889             if (arg3 == NULL) {
6890                 SWIG_null_ref("wxBitmap");
6891             }
6892             if (SWIG_arg_fail(3)) SWIG_fail;
6893         }
6894     }
6895     if (obj3) {
6896         {
6897             arg4 = &temp4;
6898             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6899         }
6900     }
6901     if (obj4) {
6902         {
6903             arg5 = &temp5;
6904             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6905         }
6906     }
6907     if (obj5) {
6908         {
6909             arg6 = (long)(SWIG_As_long(obj5));
6910             if (SWIG_arg_fail(6)) SWIG_fail;
6911         }
6912     }
6913     if (obj6) {
6914         {
6915             arg7 = wxString_in_helper(obj6);
6916             if (arg7 == NULL) SWIG_fail;
6917             temp7 = true;
6918         }
6919     }
6920     {
6921         if (!wxPyCheckForApp()) SWIG_fail;
6922         PyThreadState* __tstate = wxPyBeginAllowThreads();
6923         result = (wxStaticBitmap *)new wxStaticBitmap(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6924
6925         wxPyEndAllowThreads(__tstate);
6926         if (PyErr_Occurred()) SWIG_fail;
6927     }
6928     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBitmap, 1);
6929     {
6930         if (temp7)
6931         delete arg7;
6932     }
6933     return resultobj;
6934     fail:
6935     {
6936         if (temp7)
6937         delete arg7;
6938     }
6939     return NULL;
6940 }
6941
6942
6943 static PyObject *_wrap_new_PreStaticBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6944     PyObject *resultobj;
6945     wxStaticBitmap *result;
6946     char *kwnames[] = {
6947         NULL
6948     };
6949
6950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticBitmap",kwnames)) goto fail;
6951     {
6952         if (!wxPyCheckForApp()) SWIG_fail;
6953         PyThreadState* __tstate = wxPyBeginAllowThreads();
6954         result = (wxStaticBitmap *)new wxStaticBitmap();
6955
6956         wxPyEndAllowThreads(__tstate);
6957         if (PyErr_Occurred()) SWIG_fail;
6958     }
6959     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBitmap, 1);
6960     return resultobj;
6961     fail:
6962     return NULL;
6963 }
6964
6965
6966 static PyObject *_wrap_StaticBitmap_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6967     PyObject *resultobj;
6968     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
6969     wxWindow *arg2 = (wxWindow *) 0 ;
6970     int arg3 = (int) -1 ;
6971     wxBitmap const &arg4_defvalue = wxNullBitmap ;
6972     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
6973     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6974     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6975     wxSize const &arg6_defvalue = wxDefaultSize ;
6976     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6977     long arg7 = (long) 0 ;
6978     wxString const &arg8_defvalue = wxPyStaticBitmapNameStr ;
6979     wxString *arg8 = (wxString *) &arg8_defvalue ;
6980     bool result;
6981     wxPoint temp5 ;
6982     wxSize temp6 ;
6983     bool temp8 = false ;
6984     PyObject * obj0 = 0 ;
6985     PyObject * obj1 = 0 ;
6986     PyObject * obj2 = 0 ;
6987     PyObject * obj3 = 0 ;
6988     PyObject * obj4 = 0 ;
6989     PyObject * obj5 = 0 ;
6990     PyObject * obj6 = 0 ;
6991     PyObject * obj7 = 0 ;
6992     char *kwnames[] = {
6993         (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6994     };
6995
6996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBitmap_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
6998     if (SWIG_arg_fail(1)) SWIG_fail;
6999     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7000     if (SWIG_arg_fail(2)) SWIG_fail;
7001     if (obj2) {
7002         {
7003             arg3 = (int)(SWIG_As_int(obj2));
7004             if (SWIG_arg_fail(3)) SWIG_fail;
7005         }
7006     }
7007     if (obj3) {
7008         {
7009             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7010             if (SWIG_arg_fail(4)) SWIG_fail;
7011             if (arg4 == NULL) {
7012                 SWIG_null_ref("wxBitmap");
7013             }
7014             if (SWIG_arg_fail(4)) SWIG_fail;
7015         }
7016     }
7017     if (obj4) {
7018         {
7019             arg5 = &temp5;
7020             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
7021         }
7022     }
7023     if (obj5) {
7024         {
7025             arg6 = &temp6;
7026             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
7027         }
7028     }
7029     if (obj6) {
7030         {
7031             arg7 = (long)(SWIG_As_long(obj6));
7032             if (SWIG_arg_fail(7)) SWIG_fail;
7033         }
7034     }
7035     if (obj7) {
7036         {
7037             arg8 = wxString_in_helper(obj7);
7038             if (arg8 == NULL) SWIG_fail;
7039             temp8 = true;
7040         }
7041     }
7042     {
7043         PyThreadState* __tstate = wxPyBeginAllowThreads();
7044         result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
7045
7046         wxPyEndAllowThreads(__tstate);
7047         if (PyErr_Occurred()) SWIG_fail;
7048     }
7049     {
7050         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7051     }
7052     {
7053         if (temp8)
7054         delete arg8;
7055     }
7056     return resultobj;
7057     fail:
7058     {
7059         if (temp8)
7060         delete arg8;
7061     }
7062     return NULL;
7063 }
7064
7065
7066 static PyObject *_wrap_StaticBitmap_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7067     PyObject *resultobj;
7068     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7069     wxBitmap result;
7070     PyObject * obj0 = 0 ;
7071     char *kwnames[] = {
7072         (char *) "self", NULL
7073     };
7074
7075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBitmap_GetBitmap",kwnames,&obj0)) goto fail;
7076     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7077     if (SWIG_arg_fail(1)) SWIG_fail;
7078     {
7079         PyThreadState* __tstate = wxPyBeginAllowThreads();
7080         result = (arg1)->GetBitmap();
7081
7082         wxPyEndAllowThreads(__tstate);
7083         if (PyErr_Occurred()) SWIG_fail;
7084     }
7085     {
7086         wxBitmap * resultptr;
7087         resultptr = new wxBitmap((wxBitmap &)(result));
7088         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7089     }
7090     return resultobj;
7091     fail:
7092     return NULL;
7093 }
7094
7095
7096 static PyObject *_wrap_StaticBitmap_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7097     PyObject *resultobj;
7098     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7099     wxBitmap *arg2 = 0 ;
7100     PyObject * obj0 = 0 ;
7101     PyObject * obj1 = 0 ;
7102     char *kwnames[] = {
7103         (char *) "self",(char *) "bitmap", NULL
7104     };
7105
7106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
7107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7108     if (SWIG_arg_fail(1)) SWIG_fail;
7109     {
7110         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7111         if (SWIG_arg_fail(2)) SWIG_fail;
7112         if (arg2 == NULL) {
7113             SWIG_null_ref("wxBitmap");
7114         }
7115         if (SWIG_arg_fail(2)) SWIG_fail;
7116     }
7117     {
7118         PyThreadState* __tstate = wxPyBeginAllowThreads();
7119         (arg1)->SetBitmap((wxBitmap const &)*arg2);
7120
7121         wxPyEndAllowThreads(__tstate);
7122         if (PyErr_Occurred()) SWIG_fail;
7123     }
7124     Py_INCREF(Py_None); resultobj = Py_None;
7125     return resultobj;
7126     fail:
7127     return NULL;
7128 }
7129
7130
7131 static PyObject *_wrap_StaticBitmap_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
7132     PyObject *resultobj;
7133     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7134     wxIcon *arg2 = 0 ;
7135     PyObject * obj0 = 0 ;
7136     PyObject * obj1 = 0 ;
7137     char *kwnames[] = {
7138         (char *) "self",(char *) "icon", NULL
7139     };
7140
7141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetIcon",kwnames,&obj0,&obj1)) goto fail;
7142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7143     if (SWIG_arg_fail(1)) SWIG_fail;
7144     {
7145         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
7146         if (SWIG_arg_fail(2)) SWIG_fail;
7147         if (arg2 == NULL) {
7148             SWIG_null_ref("wxIcon");
7149         }
7150         if (SWIG_arg_fail(2)) SWIG_fail;
7151     }
7152     {
7153         PyThreadState* __tstate = wxPyBeginAllowThreads();
7154         (arg1)->SetIcon((wxIcon const &)*arg2);
7155
7156         wxPyEndAllowThreads(__tstate);
7157         if (PyErr_Occurred()) SWIG_fail;
7158     }
7159     Py_INCREF(Py_None); resultobj = Py_None;
7160     return resultobj;
7161     fail:
7162     return NULL;
7163 }
7164
7165
7166 static PyObject *_wrap_StaticBitmap_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7167     PyObject *resultobj;
7168     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7169     wxVisualAttributes result;
7170     PyObject * obj0 = 0 ;
7171     char *kwnames[] = {
7172         (char *) "variant", NULL
7173     };
7174
7175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBitmap_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7176     if (obj0) {
7177         {
7178             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7179             if (SWIG_arg_fail(1)) SWIG_fail;
7180         }
7181     }
7182     {
7183         if (!wxPyCheckForApp()) SWIG_fail;
7184         PyThreadState* __tstate = wxPyBeginAllowThreads();
7185         result = wxStaticBitmap::GetClassDefaultAttributes((wxWindowVariant )arg1);
7186
7187         wxPyEndAllowThreads(__tstate);
7188         if (PyErr_Occurred()) SWIG_fail;
7189     }
7190     {
7191         wxVisualAttributes * resultptr;
7192         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7193         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7194     }
7195     return resultobj;
7196     fail:
7197     return NULL;
7198 }
7199
7200
7201 static PyObject * StaticBitmap_swigregister(PyObject *, PyObject *args) {
7202     PyObject *obj;
7203     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7204     SWIG_TypeClientData(SWIGTYPE_p_wxStaticBitmap, obj);
7205     Py_INCREF(obj);
7206     return Py_BuildValue((char *)"");
7207 }
7208 static int _wrap_ListBoxNameStr_set(PyObject *) {
7209     PyErr_SetString(PyExc_TypeError,"Variable ListBoxNameStr is read-only.");
7210     return 1;
7211 }
7212
7213
7214 static PyObject *_wrap_ListBoxNameStr_get(void) {
7215     PyObject *pyobj;
7216
7217     {
7218 #if wxUSE_UNICODE
7219         pyobj = PyUnicode_FromWideChar((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
7220 #else
7221         pyobj = PyString_FromStringAndSize((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
7222 #endif
7223     }
7224     return pyobj;
7225 }
7226
7227
7228 static PyObject *_wrap_new_ListBox(PyObject *, PyObject *args, PyObject *kwargs) {
7229     PyObject *resultobj;
7230     wxWindow *arg1 = (wxWindow *) 0 ;
7231     int arg2 = (int) -1 ;
7232     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7233     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7234     wxSize const &arg4_defvalue = wxDefaultSize ;
7235     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7236     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
7237     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
7238     long arg6 = (long) 0 ;
7239     wxValidator const &arg7_defvalue = wxDefaultValidator ;
7240     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
7241     wxString const &arg8_defvalue = wxPyListBoxNameStr ;
7242     wxString *arg8 = (wxString *) &arg8_defvalue ;
7243     wxListBox *result;
7244     wxPoint temp3 ;
7245     wxSize temp4 ;
7246     bool temp5 = false ;
7247     bool temp8 = false ;
7248     PyObject * obj0 = 0 ;
7249     PyObject * obj1 = 0 ;
7250     PyObject * obj2 = 0 ;
7251     PyObject * obj3 = 0 ;
7252     PyObject * obj4 = 0 ;
7253     PyObject * obj5 = 0 ;
7254     PyObject * obj6 = 0 ;
7255     PyObject * obj7 = 0 ;
7256     char *kwnames[] = {
7257         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
7258     };
7259
7260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
7261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7262     if (SWIG_arg_fail(1)) SWIG_fail;
7263     if (obj1) {
7264         {
7265             arg2 = (int)(SWIG_As_int(obj1));
7266             if (SWIG_arg_fail(2)) SWIG_fail;
7267         }
7268     }
7269     if (obj2) {
7270         {
7271             arg3 = &temp3;
7272             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7273         }
7274     }
7275     if (obj3) {
7276         {
7277             arg4 = &temp4;
7278             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7279         }
7280     }
7281     if (obj4) {
7282         {
7283             if (! PySequence_Check(obj4)) {
7284                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7285                 SWIG_fail;
7286             }
7287             arg5 = new wxArrayString;
7288             temp5 = true;
7289             int i, len=PySequence_Length(obj4);
7290             for (i=0; i<len; i++) {
7291                 PyObject* item = PySequence_GetItem(obj4, i);
7292 #if wxUSE_UNICODE
7293                 PyObject* str  = PyObject_Unicode(item);
7294 #else
7295                 PyObject* str  = PyObject_Str(item);
7296 #endif
7297                 if (PyErr_Occurred())  SWIG_fail;
7298                 arg5->Add(Py2wxString(str));
7299                 Py_DECREF(item);
7300                 Py_DECREF(str);
7301             }
7302         }
7303     }
7304     if (obj5) {
7305         {
7306             arg6 = (long)(SWIG_As_long(obj5));
7307             if (SWIG_arg_fail(6)) SWIG_fail;
7308         }
7309     }
7310     if (obj6) {
7311         {
7312             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
7313             if (SWIG_arg_fail(7)) SWIG_fail;
7314             if (arg7 == NULL) {
7315                 SWIG_null_ref("wxValidator");
7316             }
7317             if (SWIG_arg_fail(7)) SWIG_fail;
7318         }
7319     }
7320     if (obj7) {
7321         {
7322             arg8 = wxString_in_helper(obj7);
7323             if (arg8 == NULL) SWIG_fail;
7324             temp8 = true;
7325         }
7326     }
7327     {
7328         if (!wxPyCheckForApp()) SWIG_fail;
7329         PyThreadState* __tstate = wxPyBeginAllowThreads();
7330         result = (wxListBox *)new wxListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
7331
7332         wxPyEndAllowThreads(__tstate);
7333         if (PyErr_Occurred()) SWIG_fail;
7334     }
7335     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListBox, 1);
7336     {
7337         if (temp5) delete arg5;
7338     }
7339     {
7340         if (temp8)
7341         delete arg8;
7342     }
7343     return resultobj;
7344     fail:
7345     {
7346         if (temp5) delete arg5;
7347     }
7348     {
7349         if (temp8)
7350         delete arg8;
7351     }
7352     return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_new_PreListBox(PyObject *, PyObject *args, PyObject *kwargs) {
7357     PyObject *resultobj;
7358     wxListBox *result;
7359     char *kwnames[] = {
7360         NULL
7361     };
7362
7363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListBox",kwnames)) goto fail;
7364     {
7365         if (!wxPyCheckForApp()) SWIG_fail;
7366         PyThreadState* __tstate = wxPyBeginAllowThreads();
7367         result = (wxListBox *)new wxListBox();
7368
7369         wxPyEndAllowThreads(__tstate);
7370         if (PyErr_Occurred()) SWIG_fail;
7371     }
7372     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListBox, 1);
7373     return resultobj;
7374     fail:
7375     return NULL;
7376 }
7377
7378
7379 static PyObject *_wrap_ListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7380     PyObject *resultobj;
7381     wxListBox *arg1 = (wxListBox *) 0 ;
7382     wxWindow *arg2 = (wxWindow *) 0 ;
7383     int arg3 = (int) -1 ;
7384     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7385     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7386     wxSize const &arg5_defvalue = wxDefaultSize ;
7387     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7388     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
7389     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
7390     long arg7 = (long) 0 ;
7391     wxValidator const &arg8_defvalue = wxDefaultValidator ;
7392     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
7393     wxString const &arg9_defvalue = wxPyListBoxNameStr ;
7394     wxString *arg9 = (wxString *) &arg9_defvalue ;
7395     bool result;
7396     wxPoint temp4 ;
7397     wxSize temp5 ;
7398     bool temp6 = false ;
7399     bool temp9 = false ;
7400     PyObject * obj0 = 0 ;
7401     PyObject * obj1 = 0 ;
7402     PyObject * obj2 = 0 ;
7403     PyObject * obj3 = 0 ;
7404     PyObject * obj4 = 0 ;
7405     PyObject * obj5 = 0 ;
7406     PyObject * obj6 = 0 ;
7407     PyObject * obj7 = 0 ;
7408     PyObject * obj8 = 0 ;
7409     char *kwnames[] = {
7410         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
7411     };
7412
7413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
7414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7415     if (SWIG_arg_fail(1)) SWIG_fail;
7416     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7417     if (SWIG_arg_fail(2)) SWIG_fail;
7418     if (obj2) {
7419         {
7420             arg3 = (int)(SWIG_As_int(obj2));
7421             if (SWIG_arg_fail(3)) SWIG_fail;
7422         }
7423     }
7424     if (obj3) {
7425         {
7426             arg4 = &temp4;
7427             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7428         }
7429     }
7430     if (obj4) {
7431         {
7432             arg5 = &temp5;
7433             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7434         }
7435     }
7436     if (obj5) {
7437         {
7438             if (! PySequence_Check(obj5)) {
7439                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7440                 SWIG_fail;
7441             }
7442             arg6 = new wxArrayString;
7443             temp6 = true;
7444             int i, len=PySequence_Length(obj5);
7445             for (i=0; i<len; i++) {
7446                 PyObject* item = PySequence_GetItem(obj5, i);
7447 #if wxUSE_UNICODE
7448                 PyObject* str  = PyObject_Unicode(item);
7449 #else
7450                 PyObject* str  = PyObject_Str(item);
7451 #endif
7452                 if (PyErr_Occurred())  SWIG_fail;
7453                 arg6->Add(Py2wxString(str));
7454                 Py_DECREF(item);
7455                 Py_DECREF(str);
7456             }
7457         }
7458     }
7459     if (obj6) {
7460         {
7461             arg7 = (long)(SWIG_As_long(obj6));
7462             if (SWIG_arg_fail(7)) SWIG_fail;
7463         }
7464     }
7465     if (obj7) {
7466         {
7467             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
7468             if (SWIG_arg_fail(8)) SWIG_fail;
7469             if (arg8 == NULL) {
7470                 SWIG_null_ref("wxValidator");
7471             }
7472             if (SWIG_arg_fail(8)) SWIG_fail;
7473         }
7474     }
7475     if (obj8) {
7476         {
7477             arg9 = wxString_in_helper(obj8);
7478             if (arg9 == NULL) SWIG_fail;
7479             temp9 = true;
7480         }
7481     }
7482     {
7483         PyThreadState* __tstate = wxPyBeginAllowThreads();
7484         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
7485
7486         wxPyEndAllowThreads(__tstate);
7487         if (PyErr_Occurred()) SWIG_fail;
7488     }
7489     {
7490         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7491     }
7492     {
7493         if (temp6) delete arg6;
7494     }
7495     {
7496         if (temp9)
7497         delete arg9;
7498     }
7499     return resultobj;
7500     fail:
7501     {
7502         if (temp6) delete arg6;
7503     }
7504     {
7505         if (temp9)
7506         delete arg9;
7507     }
7508     return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_ListBox_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
7513     PyObject *resultobj;
7514     wxListBox *arg1 = (wxListBox *) 0 ;
7515     wxString *arg2 = 0 ;
7516     int arg3 ;
7517     PyObject *arg4 = (PyObject *) NULL ;
7518     bool temp2 = false ;
7519     PyObject * obj0 = 0 ;
7520     PyObject * obj1 = 0 ;
7521     PyObject * obj2 = 0 ;
7522     PyObject * obj3 = 0 ;
7523     char *kwnames[] = {
7524         (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
7525     };
7526
7527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListBox_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7529     if (SWIG_arg_fail(1)) SWIG_fail;
7530     {
7531         arg2 = wxString_in_helper(obj1);
7532         if (arg2 == NULL) SWIG_fail;
7533         temp2 = true;
7534     }
7535     {
7536         arg3 = (int)(SWIG_As_int(obj2));
7537         if (SWIG_arg_fail(3)) SWIG_fail;
7538     }
7539     if (obj3) {
7540         arg4 = obj3;
7541     }
7542     {
7543         PyThreadState* __tstate = wxPyBeginAllowThreads();
7544         wxListBox_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
7545
7546         wxPyEndAllowThreads(__tstate);
7547         if (PyErr_Occurred()) SWIG_fail;
7548     }
7549     Py_INCREF(Py_None); resultobj = Py_None;
7550     {
7551         if (temp2)
7552         delete arg2;
7553     }
7554     return resultobj;
7555     fail:
7556     {
7557         if (temp2)
7558         delete arg2;
7559     }
7560     return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_ListBox_InsertItems(PyObject *, PyObject *args, PyObject *kwargs) {
7565     PyObject *resultobj;
7566     wxListBox *arg1 = (wxListBox *) 0 ;
7567     wxArrayString *arg2 = 0 ;
7568     int arg3 ;
7569     bool temp2 = false ;
7570     PyObject * obj0 = 0 ;
7571     PyObject * obj1 = 0 ;
7572     PyObject * obj2 = 0 ;
7573     char *kwnames[] = {
7574         (char *) "self",(char *) "items",(char *) "pos", NULL
7575     };
7576
7577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_InsertItems",kwnames,&obj0,&obj1,&obj2)) goto fail;
7578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7579     if (SWIG_arg_fail(1)) SWIG_fail;
7580     {
7581         if (! PySequence_Check(obj1)) {
7582             PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7583             SWIG_fail;
7584         }
7585         arg2 = new wxArrayString;
7586         temp2 = true;
7587         int i, len=PySequence_Length(obj1);
7588         for (i=0; i<len; i++) {
7589             PyObject* item = PySequence_GetItem(obj1, i);
7590 #if wxUSE_UNICODE
7591             PyObject* str  = PyObject_Unicode(item);
7592 #else
7593             PyObject* str  = PyObject_Str(item);
7594 #endif
7595             if (PyErr_Occurred())  SWIG_fail;
7596             arg2->Add(Py2wxString(str));
7597             Py_DECREF(item);
7598             Py_DECREF(str);
7599         }
7600     }
7601     {
7602         arg3 = (int)(SWIG_As_int(obj2));
7603         if (SWIG_arg_fail(3)) SWIG_fail;
7604     }
7605     {
7606         PyThreadState* __tstate = wxPyBeginAllowThreads();
7607         (arg1)->InsertItems((wxArrayString const &)*arg2,arg3);
7608
7609         wxPyEndAllowThreads(__tstate);
7610         if (PyErr_Occurred()) SWIG_fail;
7611     }
7612     Py_INCREF(Py_None); resultobj = Py_None;
7613     {
7614         if (temp2) delete arg2;
7615     }
7616     return resultobj;
7617     fail:
7618     {
7619         if (temp2) delete arg2;
7620     }
7621     return NULL;
7622 }
7623
7624
7625 static PyObject *_wrap_ListBox_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7626     PyObject *resultobj;
7627     wxListBox *arg1 = (wxListBox *) 0 ;
7628     wxArrayString *arg2 = 0 ;
7629     bool temp2 = false ;
7630     PyObject * obj0 = 0 ;
7631     PyObject * obj1 = 0 ;
7632     char *kwnames[] = {
7633         (char *) "self",(char *) "items", NULL
7634     };
7635
7636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Set",kwnames,&obj0,&obj1)) goto fail;
7637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7638     if (SWIG_arg_fail(1)) SWIG_fail;
7639     {
7640         if (! PySequence_Check(obj1)) {
7641             PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7642             SWIG_fail;
7643         }
7644         arg2 = new wxArrayString;
7645         temp2 = true;
7646         int i, len=PySequence_Length(obj1);
7647         for (i=0; i<len; i++) {
7648             PyObject* item = PySequence_GetItem(obj1, i);
7649 #if wxUSE_UNICODE
7650             PyObject* str  = PyObject_Unicode(item);
7651 #else
7652             PyObject* str  = PyObject_Str(item);
7653 #endif
7654             if (PyErr_Occurred())  SWIG_fail;
7655             arg2->Add(Py2wxString(str));
7656             Py_DECREF(item);
7657             Py_DECREF(str);
7658         }
7659     }
7660     {
7661         PyThreadState* __tstate = wxPyBeginAllowThreads();
7662         (arg1)->Set((wxArrayString const &)*arg2);
7663
7664         wxPyEndAllowThreads(__tstate);
7665         if (PyErr_Occurred()) SWIG_fail;
7666     }
7667     Py_INCREF(Py_None); resultobj = Py_None;
7668     {
7669         if (temp2) delete arg2;
7670     }
7671     return resultobj;
7672     fail:
7673     {
7674         if (temp2) delete arg2;
7675     }
7676     return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_ListBox_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
7681     PyObject *resultobj;
7682     wxListBox *arg1 = (wxListBox *) 0 ;
7683     int arg2 ;
7684     bool result;
7685     PyObject * obj0 = 0 ;
7686     PyObject * obj1 = 0 ;
7687     char *kwnames[] = {
7688         (char *) "self",(char *) "n", NULL
7689     };
7690
7691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
7692     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7693     if (SWIG_arg_fail(1)) SWIG_fail;
7694     {
7695         arg2 = (int)(SWIG_As_int(obj1));
7696         if (SWIG_arg_fail(2)) SWIG_fail;
7697     }
7698     {
7699         PyThreadState* __tstate = wxPyBeginAllowThreads();
7700         result = (bool)((wxListBox const *)arg1)->IsSelected(arg2);
7701
7702         wxPyEndAllowThreads(__tstate);
7703         if (PyErr_Occurred()) SWIG_fail;
7704     }
7705     {
7706         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7707     }
7708     return resultobj;
7709     fail:
7710     return NULL;
7711 }
7712
7713
7714 static PyObject *_wrap_ListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
7715     PyObject *resultobj;
7716     wxListBox *arg1 = (wxListBox *) 0 ;
7717     int arg2 ;
7718     bool arg3 = (bool) true ;
7719     PyObject * obj0 = 0 ;
7720     PyObject * obj1 = 0 ;
7721     PyObject * obj2 = 0 ;
7722     char *kwnames[] = {
7723         (char *) "self",(char *) "n",(char *) "select", NULL
7724     };
7725
7726     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
7727     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7728     if (SWIG_arg_fail(1)) SWIG_fail;
7729     {
7730         arg2 = (int)(SWIG_As_int(obj1));
7731         if (SWIG_arg_fail(2)) SWIG_fail;
7732     }
7733     if (obj2) {
7734         {
7735             arg3 = (bool)(SWIG_As_bool(obj2));
7736             if (SWIG_arg_fail(3)) SWIG_fail;
7737         }
7738     }
7739     {
7740         PyThreadState* __tstate = wxPyBeginAllowThreads();
7741         (arg1)->SetSelection(arg2,arg3);
7742
7743         wxPyEndAllowThreads(__tstate);
7744         if (PyErr_Occurred()) SWIG_fail;
7745     }
7746     Py_INCREF(Py_None); resultobj = Py_None;
7747     return resultobj;
7748     fail:
7749     return NULL;
7750 }
7751
7752
7753 static PyObject *_wrap_ListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
7754     PyObject *resultobj;
7755     wxListBox *arg1 = (wxListBox *) 0 ;
7756     int arg2 ;
7757     PyObject * obj0 = 0 ;
7758     PyObject * obj1 = 0 ;
7759     char *kwnames[] = {
7760         (char *) "self",(char *) "n", NULL
7761     };
7762
7763     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Select",kwnames,&obj0,&obj1)) goto fail;
7764     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7765     if (SWIG_arg_fail(1)) SWIG_fail;
7766     {
7767         arg2 = (int)(SWIG_As_int(obj1));
7768         if (SWIG_arg_fail(2)) SWIG_fail;
7769     }
7770     {
7771         PyThreadState* __tstate = wxPyBeginAllowThreads();
7772         (arg1)->Select(arg2);
7773
7774         wxPyEndAllowThreads(__tstate);
7775         if (PyErr_Occurred()) SWIG_fail;
7776     }
7777     Py_INCREF(Py_None); resultobj = Py_None;
7778     return resultobj;
7779     fail:
7780     return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_ListBox_Deselect(PyObject *, PyObject *args, PyObject *kwargs) {
7785     PyObject *resultobj;
7786     wxListBox *arg1 = (wxListBox *) 0 ;
7787     int arg2 ;
7788     PyObject * obj0 = 0 ;
7789     PyObject * obj1 = 0 ;
7790     char *kwnames[] = {
7791         (char *) "self",(char *) "n", NULL
7792     };
7793
7794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Deselect",kwnames,&obj0,&obj1)) goto fail;
7795     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7796     if (SWIG_arg_fail(1)) SWIG_fail;
7797     {
7798         arg2 = (int)(SWIG_As_int(obj1));
7799         if (SWIG_arg_fail(2)) SWIG_fail;
7800     }
7801     {
7802         PyThreadState* __tstate = wxPyBeginAllowThreads();
7803         (arg1)->Deselect(arg2);
7804
7805         wxPyEndAllowThreads(__tstate);
7806         if (PyErr_Occurred()) SWIG_fail;
7807     }
7808     Py_INCREF(Py_None); resultobj = Py_None;
7809     return resultobj;
7810     fail:
7811     return NULL;
7812 }
7813
7814
7815 static PyObject *_wrap_ListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
7816     PyObject *resultobj;
7817     wxListBox *arg1 = (wxListBox *) 0 ;
7818     int arg2 = (int) -1 ;
7819     PyObject * obj0 = 0 ;
7820     PyObject * obj1 = 0 ;
7821     char *kwnames[] = {
7822         (char *) "self",(char *) "itemToLeaveSelected", NULL
7823     };
7824
7825     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListBox_DeselectAll",kwnames,&obj0,&obj1)) goto fail;
7826     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7827     if (SWIG_arg_fail(1)) SWIG_fail;
7828     if (obj1) {
7829         {
7830             arg2 = (int)(SWIG_As_int(obj1));
7831             if (SWIG_arg_fail(2)) SWIG_fail;
7832         }
7833     }
7834     {
7835         PyThreadState* __tstate = wxPyBeginAllowThreads();
7836         (arg1)->DeselectAll(arg2);
7837
7838         wxPyEndAllowThreads(__tstate);
7839         if (PyErr_Occurred()) SWIG_fail;
7840     }
7841     Py_INCREF(Py_None); resultobj = Py_None;
7842     return resultobj;
7843     fail:
7844     return NULL;
7845 }
7846
7847
7848 static PyObject *_wrap_ListBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
7849     PyObject *resultobj;
7850     wxListBox *arg1 = (wxListBox *) 0 ;
7851     wxString *arg2 = 0 ;
7852     bool arg3 = (bool) true ;
7853     bool result;
7854     bool temp2 = false ;
7855     PyObject * obj0 = 0 ;
7856     PyObject * obj1 = 0 ;
7857     PyObject * obj2 = 0 ;
7858     char *kwnames[] = {
7859         (char *) "self",(char *) "s",(char *) "select", NULL
7860     };
7861
7862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetStringSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
7863     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7864     if (SWIG_arg_fail(1)) SWIG_fail;
7865     {
7866         arg2 = wxString_in_helper(obj1);
7867         if (arg2 == NULL) SWIG_fail;
7868         temp2 = true;
7869     }
7870     if (obj2) {
7871         {
7872             arg3 = (bool)(SWIG_As_bool(obj2));
7873             if (SWIG_arg_fail(3)) SWIG_fail;
7874         }
7875     }
7876     {
7877         PyThreadState* __tstate = wxPyBeginAllowThreads();
7878         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2,arg3);
7879
7880         wxPyEndAllowThreads(__tstate);
7881         if (PyErr_Occurred()) SWIG_fail;
7882     }
7883     {
7884         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7885     }
7886     {
7887         if (temp2)
7888         delete arg2;
7889     }
7890     return resultobj;
7891     fail:
7892     {
7893         if (temp2)
7894         delete arg2;
7895     }
7896     return NULL;
7897 }
7898
7899
7900 static PyObject *_wrap_ListBox_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
7901     PyObject *resultobj;
7902     wxListBox *arg1 = (wxListBox *) 0 ;
7903     PyObject *result;
7904     PyObject * obj0 = 0 ;
7905     char *kwnames[] = {
7906         (char *) "self", NULL
7907     };
7908
7909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListBox_GetSelections",kwnames,&obj0)) goto fail;
7910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7911     if (SWIG_arg_fail(1)) SWIG_fail;
7912     {
7913         PyThreadState* __tstate = wxPyBeginAllowThreads();
7914         result = (PyObject *)wxListBox_GetSelections(arg1);
7915
7916         wxPyEndAllowThreads(__tstate);
7917         if (PyErr_Occurred()) SWIG_fail;
7918     }
7919     resultobj = result;
7920     return resultobj;
7921     fail:
7922     return NULL;
7923 }
7924
7925
7926 static PyObject *_wrap_ListBox_SetFirstItem(PyObject *, PyObject *args, PyObject *kwargs) {
7927     PyObject *resultobj;
7928     wxListBox *arg1 = (wxListBox *) 0 ;
7929     int arg2 ;
7930     PyObject * obj0 = 0 ;
7931     PyObject * obj1 = 0 ;
7932     char *kwnames[] = {
7933         (char *) "self",(char *) "n", NULL
7934     };
7935
7936     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItem",kwnames,&obj0,&obj1)) goto fail;
7937     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7938     if (SWIG_arg_fail(1)) SWIG_fail;
7939     {
7940         arg2 = (int)(SWIG_As_int(obj1));
7941         if (SWIG_arg_fail(2)) SWIG_fail;
7942     }
7943     {
7944         PyThreadState* __tstate = wxPyBeginAllowThreads();
7945         (arg1)->SetFirstItem(arg2);
7946
7947         wxPyEndAllowThreads(__tstate);
7948         if (PyErr_Occurred()) SWIG_fail;
7949     }
7950     Py_INCREF(Py_None); resultobj = Py_None;
7951     return resultobj;
7952     fail:
7953     return NULL;
7954 }
7955
7956
7957 static PyObject *_wrap_ListBox_SetFirstItemStr(PyObject *, PyObject *args, PyObject *kwargs) {
7958     PyObject *resultobj;
7959     wxListBox *arg1 = (wxListBox *) 0 ;
7960     wxString *arg2 = 0 ;
7961     bool temp2 = false ;
7962     PyObject * obj0 = 0 ;
7963     PyObject * obj1 = 0 ;
7964     char *kwnames[] = {
7965         (char *) "self",(char *) "s", NULL
7966     };
7967
7968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItemStr",kwnames,&obj0,&obj1)) goto fail;
7969     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7970     if (SWIG_arg_fail(1)) SWIG_fail;
7971     {
7972         arg2 = wxString_in_helper(obj1);
7973         if (arg2 == NULL) SWIG_fail;
7974         temp2 = true;
7975     }
7976     {
7977         PyThreadState* __tstate = wxPyBeginAllowThreads();
7978         (arg1)->SetFirstItem((wxString const &)*arg2);
7979
7980         wxPyEndAllowThreads(__tstate);
7981         if (PyErr_Occurred()) SWIG_fail;
7982     }
7983     Py_INCREF(Py_None); resultobj = Py_None;
7984     {
7985         if (temp2)
7986         delete arg2;
7987     }
7988     return resultobj;
7989     fail:
7990     {
7991         if (temp2)
7992         delete arg2;
7993     }
7994     return NULL;
7995 }
7996
7997
7998 static PyObject *_wrap_ListBox_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
7999     PyObject *resultobj;
8000     wxListBox *arg1 = (wxListBox *) 0 ;
8001     int arg2 ;
8002     PyObject * obj0 = 0 ;
8003     PyObject * obj1 = 0 ;
8004     char *kwnames[] = {
8005         (char *) "self",(char *) "n", NULL
8006     };
8007
8008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
8009     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8010     if (SWIG_arg_fail(1)) SWIG_fail;
8011     {
8012         arg2 = (int)(SWIG_As_int(obj1));
8013         if (SWIG_arg_fail(2)) SWIG_fail;
8014     }
8015     {
8016         PyThreadState* __tstate = wxPyBeginAllowThreads();
8017         (arg1)->EnsureVisible(arg2);
8018
8019         wxPyEndAllowThreads(__tstate);
8020         if (PyErr_Occurred()) SWIG_fail;
8021     }
8022     Py_INCREF(Py_None); resultobj = Py_None;
8023     return resultobj;
8024     fail:
8025     return NULL;
8026 }
8027
8028
8029 static PyObject *_wrap_ListBox_AppendAndEnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8030     PyObject *resultobj;
8031     wxListBox *arg1 = (wxListBox *) 0 ;
8032     wxString *arg2 = 0 ;
8033     bool temp2 = false ;
8034     PyObject * obj0 = 0 ;
8035     PyObject * obj1 = 0 ;
8036     char *kwnames[] = {
8037         (char *) "self",(char *) "s", NULL
8038     };
8039
8040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_AppendAndEnsureVisible",kwnames,&obj0,&obj1)) goto fail;
8041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8042     if (SWIG_arg_fail(1)) SWIG_fail;
8043     {
8044         arg2 = wxString_in_helper(obj1);
8045         if (arg2 == NULL) SWIG_fail;
8046         temp2 = true;
8047     }
8048     {
8049         PyThreadState* __tstate = wxPyBeginAllowThreads();
8050         (arg1)->AppendAndEnsureVisible((wxString const &)*arg2);
8051
8052         wxPyEndAllowThreads(__tstate);
8053         if (PyErr_Occurred()) SWIG_fail;
8054     }
8055     Py_INCREF(Py_None); resultobj = Py_None;
8056     {
8057         if (temp2)
8058         delete arg2;
8059     }
8060     return resultobj;
8061     fail:
8062     {
8063         if (temp2)
8064         delete arg2;
8065     }
8066     return NULL;
8067 }
8068
8069
8070 static PyObject *_wrap_ListBox_IsSorted(PyObject *, PyObject *args, PyObject *kwargs) {
8071     PyObject *resultobj;
8072     wxListBox *arg1 = (wxListBox *) 0 ;
8073     bool result;
8074     PyObject * obj0 = 0 ;
8075     char *kwnames[] = {
8076         (char *) "self", NULL
8077     };
8078
8079     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListBox_IsSorted",kwnames,&obj0)) goto fail;
8080     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8081     if (SWIG_arg_fail(1)) SWIG_fail;
8082     {
8083         PyThreadState* __tstate = wxPyBeginAllowThreads();
8084         result = (bool)((wxListBox const *)arg1)->IsSorted();
8085
8086         wxPyEndAllowThreads(__tstate);
8087         if (PyErr_Occurred()) SWIG_fail;
8088     }
8089     {
8090         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8091     }
8092     return resultobj;
8093     fail:
8094     return NULL;
8095 }
8096
8097
8098 static PyObject *_wrap_ListBox_SetItemForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8099     PyObject *resultobj;
8100     wxListBox *arg1 = (wxListBox *) 0 ;
8101     int arg2 ;
8102     wxColour *arg3 = 0 ;
8103     wxColour temp3 ;
8104     PyObject * obj0 = 0 ;
8105     PyObject * obj1 = 0 ;
8106     PyObject * obj2 = 0 ;
8107     char *kwnames[] = {
8108         (char *) "self",(char *) "item",(char *) "c", NULL
8109     };
8110
8111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemForegroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
8112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8113     if (SWIG_arg_fail(1)) SWIG_fail;
8114     {
8115         arg2 = (int)(SWIG_As_int(obj1));
8116         if (SWIG_arg_fail(2)) SWIG_fail;
8117     }
8118     {
8119         arg3 = &temp3;
8120         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8121     }
8122     {
8123         PyThreadState* __tstate = wxPyBeginAllowThreads();
8124         wxListBox_SetItemForegroundColour(arg1,arg2,(wxColour const &)*arg3);
8125
8126         wxPyEndAllowThreads(__tstate);
8127         if (PyErr_Occurred()) SWIG_fail;
8128     }
8129     Py_INCREF(Py_None); resultobj = Py_None;
8130     return resultobj;
8131     fail:
8132     return NULL;
8133 }
8134
8135
8136 static PyObject *_wrap_ListBox_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8137     PyObject *resultobj;
8138     wxListBox *arg1 = (wxListBox *) 0 ;
8139     int arg2 ;
8140     wxColour *arg3 = 0 ;
8141     wxColour temp3 ;
8142     PyObject * obj0 = 0 ;
8143     PyObject * obj1 = 0 ;
8144     PyObject * obj2 = 0 ;
8145     char *kwnames[] = {
8146         (char *) "self",(char *) "item",(char *) "c", NULL
8147     };
8148
8149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
8150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8151     if (SWIG_arg_fail(1)) SWIG_fail;
8152     {
8153         arg2 = (int)(SWIG_As_int(obj1));
8154         if (SWIG_arg_fail(2)) SWIG_fail;
8155     }
8156     {
8157         arg3 = &temp3;
8158         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8159     }
8160     {
8161         PyThreadState* __tstate = wxPyBeginAllowThreads();
8162         wxListBox_SetItemBackgroundColour(arg1,arg2,(wxColour const &)*arg3);
8163
8164         wxPyEndAllowThreads(__tstate);
8165         if (PyErr_Occurred()) SWIG_fail;
8166     }
8167     Py_INCREF(Py_None); resultobj = Py_None;
8168     return resultobj;
8169     fail:
8170     return NULL;
8171 }
8172
8173
8174 static PyObject *_wrap_ListBox_SetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
8175     PyObject *resultobj;
8176     wxListBox *arg1 = (wxListBox *) 0 ;
8177     int arg2 ;
8178     wxFont *arg3 = 0 ;
8179     PyObject * obj0 = 0 ;
8180     PyObject * obj1 = 0 ;
8181     PyObject * obj2 = 0 ;
8182     char *kwnames[] = {
8183         (char *) "self",(char *) "item",(char *) "f", NULL
8184     };
8185
8186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
8187     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8188     if (SWIG_arg_fail(1)) SWIG_fail;
8189     {
8190         arg2 = (int)(SWIG_As_int(obj1));
8191         if (SWIG_arg_fail(2)) SWIG_fail;
8192     }
8193     {
8194         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8195         if (SWIG_arg_fail(3)) SWIG_fail;
8196         if (arg3 == NULL) {
8197             SWIG_null_ref("wxFont");
8198         }
8199         if (SWIG_arg_fail(3)) SWIG_fail;
8200     }
8201     {
8202         PyThreadState* __tstate = wxPyBeginAllowThreads();
8203         wxListBox_SetItemFont(arg1,arg2,(wxFont const &)*arg3);
8204
8205         wxPyEndAllowThreads(__tstate);
8206         if (PyErr_Occurred()) SWIG_fail;
8207     }
8208     Py_INCREF(Py_None); resultobj = Py_None;
8209     return resultobj;
8210     fail:
8211     return NULL;
8212 }
8213
8214
8215 static PyObject *_wrap_ListBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8216     PyObject *resultobj;
8217     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8218     wxVisualAttributes result;
8219     PyObject * obj0 = 0 ;
8220     char *kwnames[] = {
8221         (char *) "variant", NULL
8222     };
8223
8224     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8225     if (obj0) {
8226         {
8227             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8228             if (SWIG_arg_fail(1)) SWIG_fail;
8229         }
8230     }
8231     {
8232         if (!wxPyCheckForApp()) SWIG_fail;
8233         PyThreadState* __tstate = wxPyBeginAllowThreads();
8234         result = wxListBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
8235
8236         wxPyEndAllowThreads(__tstate);
8237         if (PyErr_Occurred()) SWIG_fail;
8238     }
8239     {
8240         wxVisualAttributes * resultptr;
8241         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8242         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8243     }
8244     return resultobj;
8245     fail:
8246     return NULL;
8247 }
8248
8249
8250 static PyObject * ListBox_swigregister(PyObject *, PyObject *args) {
8251     PyObject *obj;
8252     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8253     SWIG_TypeClientData(SWIGTYPE_p_wxListBox, obj);
8254     Py_INCREF(obj);
8255     return Py_BuildValue((char *)"");
8256 }
8257 static PyObject *_wrap_new_CheckListBox(PyObject *, PyObject *args, PyObject *kwargs) {
8258     PyObject *resultobj;
8259     wxWindow *arg1 = (wxWindow *) 0 ;
8260     int arg2 = (int) -1 ;
8261     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8262     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8263     wxSize const &arg4_defvalue = wxDefaultSize ;
8264     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8265     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
8266     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
8267     long arg6 = (long) 0 ;
8268     wxValidator const &arg7_defvalue = wxDefaultValidator ;
8269     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
8270     wxString const &arg8_defvalue = wxPyListBoxNameStr ;
8271     wxString *arg8 = (wxString *) &arg8_defvalue ;
8272     wxCheckListBox *result;
8273     wxPoint temp3 ;
8274     wxSize temp4 ;
8275     bool temp5 = false ;
8276     bool temp8 = false ;
8277     PyObject * obj0 = 0 ;
8278     PyObject * obj1 = 0 ;
8279     PyObject * obj2 = 0 ;
8280     PyObject * obj3 = 0 ;
8281     PyObject * obj4 = 0 ;
8282     PyObject * obj5 = 0 ;
8283     PyObject * obj6 = 0 ;
8284     PyObject * obj7 = 0 ;
8285     char *kwnames[] = {
8286         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
8287     };
8288
8289     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
8290     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8291     if (SWIG_arg_fail(1)) SWIG_fail;
8292     if (obj1) {
8293         {
8294             arg2 = (int)(SWIG_As_int(obj1));
8295             if (SWIG_arg_fail(2)) SWIG_fail;
8296         }
8297     }
8298     if (obj2) {
8299         {
8300             arg3 = &temp3;
8301             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8302         }
8303     }
8304     if (obj3) {
8305         {
8306             arg4 = &temp4;
8307             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8308         }
8309     }
8310     if (obj4) {
8311         {
8312             if (! PySequence_Check(obj4)) {
8313                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
8314                 SWIG_fail;
8315             }
8316             arg5 = new wxArrayString;
8317             temp5 = true;
8318             int i, len=PySequence_Length(obj4);
8319             for (i=0; i<len; i++) {
8320                 PyObject* item = PySequence_GetItem(obj4, i);
8321 #if wxUSE_UNICODE
8322                 PyObject* str  = PyObject_Unicode(item);
8323 #else
8324                 PyObject* str  = PyObject_Str(item);
8325 #endif
8326                 if (PyErr_Occurred())  SWIG_fail;
8327                 arg5->Add(Py2wxString(str));
8328                 Py_DECREF(item);
8329                 Py_DECREF(str);
8330             }
8331         }
8332     }
8333     if (obj5) {
8334         {
8335             arg6 = (long)(SWIG_As_long(obj5));
8336             if (SWIG_arg_fail(6)) SWIG_fail;
8337         }
8338     }
8339     if (obj6) {
8340         {
8341             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
8342             if (SWIG_arg_fail(7)) SWIG_fail;
8343             if (arg7 == NULL) {
8344                 SWIG_null_ref("wxValidator");
8345             }
8346             if (SWIG_arg_fail(7)) SWIG_fail;
8347         }
8348     }
8349     if (obj7) {
8350         {
8351             arg8 = wxString_in_helper(obj7);
8352             if (arg8 == NULL) SWIG_fail;
8353             temp8 = true;
8354         }
8355     }
8356     {
8357         if (!wxPyCheckForApp()) SWIG_fail;
8358         PyThreadState* __tstate = wxPyBeginAllowThreads();
8359         result = (wxCheckListBox *)new wxCheckListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
8360
8361         wxPyEndAllowThreads(__tstate);
8362         if (PyErr_Occurred()) SWIG_fail;
8363     }
8364     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckListBox, 1);
8365     {
8366         if (temp5) delete arg5;
8367     }
8368     {
8369         if (temp8)
8370         delete arg8;
8371     }
8372     return resultobj;
8373     fail:
8374     {
8375         if (temp5) delete arg5;
8376     }
8377     {
8378         if (temp8)
8379         delete arg8;
8380     }
8381     return NULL;
8382 }
8383
8384
8385 static PyObject *_wrap_new_PreCheckListBox(PyObject *, PyObject *args, PyObject *kwargs) {
8386     PyObject *resultobj;
8387     wxCheckListBox *result;
8388     char *kwnames[] = {
8389         NULL
8390     };
8391
8392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreCheckListBox",kwnames)) goto fail;
8393     {
8394         if (!wxPyCheckForApp()) SWIG_fail;
8395         PyThreadState* __tstate = wxPyBeginAllowThreads();
8396         result = (wxCheckListBox *)new wxCheckListBox();
8397
8398         wxPyEndAllowThreads(__tstate);
8399         if (PyErr_Occurred()) SWIG_fail;
8400     }
8401     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckListBox, 1);
8402     return resultobj;
8403     fail:
8404     return NULL;
8405 }
8406
8407
8408 static PyObject *_wrap_CheckListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8409     PyObject *resultobj;
8410     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8411     wxWindow *arg2 = (wxWindow *) 0 ;
8412     int arg3 = (int) -1 ;
8413     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8414     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8415     wxSize const &arg5_defvalue = wxDefaultSize ;
8416     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8417     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
8418     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
8419     long arg7 = (long) 0 ;
8420     wxValidator const &arg8_defvalue = wxDefaultValidator ;
8421     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
8422     wxString const &arg9_defvalue = wxPyListBoxNameStr ;
8423     wxString *arg9 = (wxString *) &arg9_defvalue ;
8424     bool result;
8425     wxPoint temp4 ;
8426     wxSize temp5 ;
8427     bool temp6 = false ;
8428     bool temp9 = false ;
8429     PyObject * obj0 = 0 ;
8430     PyObject * obj1 = 0 ;
8431     PyObject * obj2 = 0 ;
8432     PyObject * obj3 = 0 ;
8433     PyObject * obj4 = 0 ;
8434     PyObject * obj5 = 0 ;
8435     PyObject * obj6 = 0 ;
8436     PyObject * obj7 = 0 ;
8437     PyObject * obj8 = 0 ;
8438     char *kwnames[] = {
8439         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
8440     };
8441
8442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
8443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8444     if (SWIG_arg_fail(1)) SWIG_fail;
8445     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8446     if (SWIG_arg_fail(2)) SWIG_fail;
8447     if (obj2) {
8448         {
8449             arg3 = (int)(SWIG_As_int(obj2));
8450             if (SWIG_arg_fail(3)) SWIG_fail;
8451         }
8452     }
8453     if (obj3) {
8454         {
8455             arg4 = &temp4;
8456             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8457         }
8458     }
8459     if (obj4) {
8460         {
8461             arg5 = &temp5;
8462             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8463         }
8464     }
8465     if (obj5) {
8466         {
8467             if (! PySequence_Check(obj5)) {
8468                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
8469                 SWIG_fail;
8470             }
8471             arg6 = new wxArrayString;
8472             temp6 = true;
8473             int i, len=PySequence_Length(obj5);
8474             for (i=0; i<len; i++) {
8475                 PyObject* item = PySequence_GetItem(obj5, i);
8476 #if wxUSE_UNICODE
8477                 PyObject* str  = PyObject_Unicode(item);
8478 #else
8479                 PyObject* str  = PyObject_Str(item);
8480 #endif
8481                 if (PyErr_Occurred())  SWIG_fail;
8482                 arg6->Add(Py2wxString(str));
8483                 Py_DECREF(item);
8484                 Py_DECREF(str);
8485             }
8486         }
8487     }
8488     if (obj6) {
8489         {
8490             arg7 = (long)(SWIG_As_long(obj6));
8491             if (SWIG_arg_fail(7)) SWIG_fail;
8492         }
8493     }
8494     if (obj7) {
8495         {
8496             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
8497             if (SWIG_arg_fail(8)) SWIG_fail;
8498             if (arg8 == NULL) {
8499                 SWIG_null_ref("wxValidator");
8500             }
8501             if (SWIG_arg_fail(8)) SWIG_fail;
8502         }
8503     }
8504     if (obj8) {
8505         {
8506             arg9 = wxString_in_helper(obj8);
8507             if (arg9 == NULL) SWIG_fail;
8508             temp9 = true;
8509         }
8510     }
8511     {
8512         PyThreadState* __tstate = wxPyBeginAllowThreads();
8513         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
8514
8515         wxPyEndAllowThreads(__tstate);
8516         if (PyErr_Occurred()) SWIG_fail;
8517     }
8518     {
8519         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8520     }
8521     {
8522         if (temp6) delete arg6;
8523     }
8524     {
8525         if (temp9)
8526         delete arg9;
8527     }
8528     return resultobj;
8529     fail:
8530     {
8531         if (temp6) delete arg6;
8532     }
8533     {
8534         if (temp9)
8535         delete arg9;
8536     }
8537     return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_CheckListBox_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
8542     PyObject *resultobj;
8543     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8544     int arg2 ;
8545     bool result;
8546     PyObject * obj0 = 0 ;
8547     PyObject * obj1 = 0 ;
8548     char *kwnames[] = {
8549         (char *) "self",(char *) "index", NULL
8550     };
8551
8552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckListBox_IsChecked",kwnames,&obj0,&obj1)) goto fail;
8553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8554     if (SWIG_arg_fail(1)) SWIG_fail;
8555     {
8556         arg2 = (int)(SWIG_As_int(obj1));
8557         if (SWIG_arg_fail(2)) SWIG_fail;
8558     }
8559     {
8560         PyThreadState* __tstate = wxPyBeginAllowThreads();
8561         result = (bool)(arg1)->IsChecked(arg2);
8562
8563         wxPyEndAllowThreads(__tstate);
8564         if (PyErr_Occurred()) SWIG_fail;
8565     }
8566     {
8567         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568     }
8569     return resultobj;
8570     fail:
8571     return NULL;
8572 }
8573
8574
8575 static PyObject *_wrap_CheckListBox_Check(PyObject *, PyObject *args, PyObject *kwargs) {
8576     PyObject *resultobj;
8577     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8578     int arg2 ;
8579     int arg3 = (int) true ;
8580     PyObject * obj0 = 0 ;
8581     PyObject * obj1 = 0 ;
8582     PyObject * obj2 = 0 ;
8583     char *kwnames[] = {
8584         (char *) "self",(char *) "index",(char *) "check", NULL
8585     };
8586
8587     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:CheckListBox_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
8588     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8589     if (SWIG_arg_fail(1)) SWIG_fail;
8590     {
8591         arg2 = (int)(SWIG_As_int(obj1));
8592         if (SWIG_arg_fail(2)) SWIG_fail;
8593     }
8594     if (obj2) {
8595         {
8596             arg3 = (int)(SWIG_As_int(obj2));
8597             if (SWIG_arg_fail(3)) SWIG_fail;
8598         }
8599     }
8600     {
8601         PyThreadState* __tstate = wxPyBeginAllowThreads();
8602         (arg1)->Check(arg2,arg3);
8603
8604         wxPyEndAllowThreads(__tstate);
8605         if (PyErr_Occurred()) SWIG_fail;
8606     }
8607     Py_INCREF(Py_None); resultobj = Py_None;
8608     return resultobj;
8609     fail:
8610     return NULL;
8611 }
8612
8613
8614 static PyObject *_wrap_CheckListBox_GetItemHeight(PyObject *, PyObject *args, PyObject *kwargs) {
8615     PyObject *resultobj;
8616     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8617     int result;
8618     PyObject * obj0 = 0 ;
8619     char *kwnames[] = {
8620         (char *) "self", NULL
8621     };
8622
8623     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckListBox_GetItemHeight",kwnames,&obj0)) goto fail;
8624     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8625     if (SWIG_arg_fail(1)) SWIG_fail;
8626     {
8627         PyThreadState* __tstate = wxPyBeginAllowThreads();
8628         result = (int)(arg1)->GetItemHeight();
8629
8630         wxPyEndAllowThreads(__tstate);
8631         if (PyErr_Occurred()) SWIG_fail;
8632     }
8633     {
8634         resultobj = SWIG_From_int((int)(result));
8635     }
8636     return resultobj;
8637     fail:
8638     return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_CheckListBox_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8643     PyObject *resultobj;
8644     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8645     wxPoint *arg2 = 0 ;
8646     int result;
8647     wxPoint temp2 ;
8648     PyObject * obj0 = 0 ;
8649     PyObject * obj1 = 0 ;
8650     char *kwnames[] = {
8651         (char *) "self",(char *) "pt", NULL
8652     };
8653
8654     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckListBox_HitTest",kwnames,&obj0,&obj1)) goto fail;
8655     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8656     if (SWIG_arg_fail(1)) SWIG_fail;
8657     {
8658         arg2 = &temp2;
8659         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8660     }
8661     {
8662         PyThreadState* __tstate = wxPyBeginAllowThreads();
8663         result = (int)((wxCheckListBox const *)arg1)->HitTest((wxPoint const &)*arg2);
8664
8665         wxPyEndAllowThreads(__tstate);
8666         if (PyErr_Occurred()) SWIG_fail;
8667     }
8668     {
8669         resultobj = SWIG_From_int((int)(result));
8670     }
8671     return resultobj;
8672     fail:
8673     return NULL;
8674 }
8675
8676
8677 static PyObject *_wrap_CheckListBox_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
8678     PyObject *resultobj;
8679     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8680     int arg2 ;
8681     int arg3 ;
8682     int result;
8683     PyObject * obj0 = 0 ;
8684     PyObject * obj1 = 0 ;
8685     PyObject * obj2 = 0 ;
8686     char *kwnames[] = {
8687         (char *) "self",(char *) "x",(char *) "y", NULL
8688     };
8689
8690     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:CheckListBox_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
8691     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8692     if (SWIG_arg_fail(1)) SWIG_fail;
8693     {
8694         arg2 = (int)(SWIG_As_int(obj1));
8695         if (SWIG_arg_fail(2)) SWIG_fail;
8696     }
8697     {
8698         arg3 = (int)(SWIG_As_int(obj2));
8699         if (SWIG_arg_fail(3)) SWIG_fail;
8700     }
8701     {
8702         PyThreadState* __tstate = wxPyBeginAllowThreads();
8703         result = (int)((wxCheckListBox const *)arg1)->HitTest(arg2,arg3);
8704
8705         wxPyEndAllowThreads(__tstate);
8706         if (PyErr_Occurred()) SWIG_fail;
8707     }
8708     {
8709         resultobj = SWIG_From_int((int)(result));
8710     }
8711     return resultobj;
8712     fail:
8713     return NULL;
8714 }
8715
8716
8717 static PyObject * CheckListBox_swigregister(PyObject *, PyObject *args) {
8718     PyObject *obj;
8719     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8720     SWIG_TypeClientData(SWIGTYPE_p_wxCheckListBox, obj);
8721     Py_INCREF(obj);
8722     return Py_BuildValue((char *)"");
8723 }
8724 static int _wrap_TextCtrlNameStr_set(PyObject *) {
8725     PyErr_SetString(PyExc_TypeError,"Variable TextCtrlNameStr is read-only.");
8726     return 1;
8727 }
8728
8729
8730 static PyObject *_wrap_TextCtrlNameStr_get(void) {
8731     PyObject *pyobj;
8732
8733     {
8734 #if wxUSE_UNICODE
8735         pyobj = PyUnicode_FromWideChar((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
8736 #else
8737         pyobj = PyString_FromStringAndSize((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
8738 #endif
8739     }
8740     return pyobj;
8741 }
8742
8743
8744 static PyObject *_wrap_new_TextAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8745     PyObject *resultobj;
8746     wxColour const &arg1_defvalue = wxNullColour ;
8747     wxColour *arg1 = (wxColour *) &arg1_defvalue ;
8748     wxColour const &arg2_defvalue = wxNullColour ;
8749     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
8750     wxFont const &arg3_defvalue = wxNullFont ;
8751     wxFont *arg3 = (wxFont *) &arg3_defvalue ;
8752     wxTextAttrAlignment arg4 = (wxTextAttrAlignment) wxTEXT_ALIGNMENT_DEFAULT ;
8753     wxTextAttr *result;
8754     wxColour temp1 ;
8755     wxColour temp2 ;
8756     PyObject * obj0 = 0 ;
8757     PyObject * obj1 = 0 ;
8758     PyObject * obj2 = 0 ;
8759     PyObject * obj3 = 0 ;
8760     char *kwnames[] = {
8761         (char *) "colText",(char *) "colBack",(char *) "font",(char *) "alignment", NULL
8762     };
8763
8764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TextAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8765     if (obj0) {
8766         {
8767             arg1 = &temp1;
8768             if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
8769         }
8770     }
8771     if (obj1) {
8772         {
8773             arg2 = &temp2;
8774             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8775         }
8776     }
8777     if (obj2) {
8778         {
8779             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8780             if (SWIG_arg_fail(3)) SWIG_fail;
8781             if (arg3 == NULL) {
8782                 SWIG_null_ref("wxFont");
8783             }
8784             if (SWIG_arg_fail(3)) SWIG_fail;
8785         }
8786     }
8787     if (obj3) {
8788         {
8789             arg4 = (wxTextAttrAlignment)(SWIG_As_int(obj3));
8790             if (SWIG_arg_fail(4)) SWIG_fail;
8791         }
8792     }
8793     {
8794         PyThreadState* __tstate = wxPyBeginAllowThreads();
8795         result = (wxTextAttr *)new wxTextAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3,(wxTextAttrAlignment )arg4);
8796
8797         wxPyEndAllowThreads(__tstate);
8798         if (PyErr_Occurred()) SWIG_fail;
8799     }
8800     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextAttr, 1);
8801     return resultobj;
8802     fail:
8803     return NULL;
8804 }
8805
8806
8807 static PyObject *_wrap_delete_TextAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8808     PyObject *resultobj;
8809     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8810     PyObject * obj0 = 0 ;
8811     char *kwnames[] = {
8812         (char *) "self", NULL
8813     };
8814
8815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TextAttr",kwnames,&obj0)) goto fail;
8816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8817     if (SWIG_arg_fail(1)) SWIG_fail;
8818     {
8819         PyThreadState* __tstate = wxPyBeginAllowThreads();
8820         delete arg1;
8821
8822         wxPyEndAllowThreads(__tstate);
8823         if (PyErr_Occurred()) SWIG_fail;
8824     }
8825     Py_INCREF(Py_None); resultobj = Py_None;
8826     return resultobj;
8827     fail:
8828     return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_TextAttr_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8833     PyObject *resultobj;
8834     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8835     PyObject * obj0 = 0 ;
8836     char *kwnames[] = {
8837         (char *) "self", NULL
8838     };
8839
8840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_Init",kwnames,&obj0)) goto fail;
8841     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8842     if (SWIG_arg_fail(1)) SWIG_fail;
8843     {
8844         PyThreadState* __tstate = wxPyBeginAllowThreads();
8845         (arg1)->Init();
8846
8847         wxPyEndAllowThreads(__tstate);
8848         if (PyErr_Occurred()) SWIG_fail;
8849     }
8850     Py_INCREF(Py_None); resultobj = Py_None;
8851     return resultobj;
8852     fail:
8853     return NULL;
8854 }
8855
8856
8857 static PyObject *_wrap_TextAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
8858     PyObject *resultobj;
8859     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8860     wxColour *arg2 = 0 ;
8861     wxColour temp2 ;
8862     PyObject * obj0 = 0 ;
8863     PyObject * obj1 = 0 ;
8864     char *kwnames[] = {
8865         (char *) "self",(char *) "colText", NULL
8866     };
8867
8868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
8869     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8870     if (SWIG_arg_fail(1)) SWIG_fail;
8871     {
8872         arg2 = &temp2;
8873         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8874     }
8875     {
8876         PyThreadState* __tstate = wxPyBeginAllowThreads();
8877         (arg1)->SetTextColour((wxColour const &)*arg2);
8878
8879         wxPyEndAllowThreads(__tstate);
8880         if (PyErr_Occurred()) SWIG_fail;
8881     }
8882     Py_INCREF(Py_None); resultobj = Py_None;
8883     return resultobj;
8884     fail:
8885     return NULL;
8886 }
8887
8888
8889 static PyObject *_wrap_TextAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8890     PyObject *resultobj;
8891     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8892     wxColour *arg2 = 0 ;
8893     wxColour temp2 ;
8894     PyObject * obj0 = 0 ;
8895     PyObject * obj1 = 0 ;
8896     char *kwnames[] = {
8897         (char *) "self",(char *) "colBack", NULL
8898     };
8899
8900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
8901     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8902     if (SWIG_arg_fail(1)) SWIG_fail;
8903     {
8904         arg2 = &temp2;
8905         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8906     }
8907     {
8908         PyThreadState* __tstate = wxPyBeginAllowThreads();
8909         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
8910
8911         wxPyEndAllowThreads(__tstate);
8912         if (PyErr_Occurred()) SWIG_fail;
8913     }
8914     Py_INCREF(Py_None); resultobj = Py_None;
8915     return resultobj;
8916     fail:
8917     return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_TextAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
8922     PyObject *resultobj;
8923     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8924     wxFont *arg2 = 0 ;
8925     long arg3 = (long) wxTEXT_ATTR_FONT ;
8926     PyObject * obj0 = 0 ;
8927     PyObject * obj1 = 0 ;
8928     PyObject * obj2 = 0 ;
8929     char *kwnames[] = {
8930         (char *) "self",(char *) "font",(char *) "flags", NULL
8931     };
8932
8933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
8934     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8935     if (SWIG_arg_fail(1)) SWIG_fail;
8936     {
8937         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8938         if (SWIG_arg_fail(2)) SWIG_fail;
8939         if (arg2 == NULL) {
8940             SWIG_null_ref("wxFont");
8941         }
8942         if (SWIG_arg_fail(2)) SWIG_fail;
8943     }
8944     if (obj2) {
8945         {
8946             arg3 = (long)(SWIG_As_long(obj2));
8947             if (SWIG_arg_fail(3)) SWIG_fail;
8948         }
8949     }
8950     {
8951         PyThreadState* __tstate = wxPyBeginAllowThreads();
8952         (arg1)->SetFont((wxFont const &)*arg2,arg3);
8953
8954         wxPyEndAllowThreads(__tstate);
8955         if (PyErr_Occurred()) SWIG_fail;
8956     }
8957     Py_INCREF(Py_None); resultobj = Py_None;
8958     return resultobj;
8959     fail:
8960     return NULL;
8961 }
8962
8963
8964 static PyObject *_wrap_TextAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
8965     PyObject *resultobj;
8966     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8967     wxTextAttrAlignment arg2 ;
8968     PyObject * obj0 = 0 ;
8969     PyObject * obj1 = 0 ;
8970     char *kwnames[] = {
8971         (char *) "self",(char *) "alignment", NULL
8972     };
8973
8974     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
8975     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8976     if (SWIG_arg_fail(1)) SWIG_fail;
8977     {
8978         arg2 = (wxTextAttrAlignment)(SWIG_As_int(obj1));
8979         if (SWIG_arg_fail(2)) SWIG_fail;
8980     }
8981     {
8982         PyThreadState* __tstate = wxPyBeginAllowThreads();
8983         (arg1)->SetAlignment((wxTextAttrAlignment )arg2);
8984
8985         wxPyEndAllowThreads(__tstate);
8986         if (PyErr_Occurred()) SWIG_fail;
8987     }
8988     Py_INCREF(Py_None); resultobj = Py_None;
8989     return resultobj;
8990     fail:
8991     return NULL;
8992 }
8993
8994
8995 static PyObject *_wrap_TextAttr_SetTabs(PyObject *, PyObject *args, PyObject *kwargs) {
8996     PyObject *resultobj;
8997     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8998     wxArrayInt *arg2 = 0 ;
8999     bool temp2 = false ;
9000     PyObject * obj0 = 0 ;
9001     PyObject * obj1 = 0 ;
9002     char *kwnames[] = {
9003         (char *) "self",(char *) "tabs", NULL
9004     };
9005
9006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTabs",kwnames,&obj0,&obj1)) goto fail;
9007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9008     if (SWIG_arg_fail(1)) SWIG_fail;
9009     {
9010         if (! PySequence_Check(obj1)) {
9011             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
9012             SWIG_fail;
9013         }
9014         arg2 = new wxArrayInt;
9015         temp2 = true;
9016         int i, len=PySequence_Length(obj1);
9017         for (i=0; i<len; i++) {
9018             PyObject* item = PySequence_GetItem(obj1, i);
9019             PyObject* number  = PyNumber_Int(item);
9020             arg2->Add(PyInt_AS_LONG(number));
9021             Py_DECREF(item);
9022             Py_DECREF(number);
9023         }
9024     }
9025     {
9026         PyThreadState* __tstate = wxPyBeginAllowThreads();
9027         (arg1)->SetTabs((wxArrayInt const &)*arg2);
9028
9029         wxPyEndAllowThreads(__tstate);
9030         if (PyErr_Occurred()) SWIG_fail;
9031     }
9032     Py_INCREF(Py_None); resultobj = Py_None;
9033     {
9034         if (temp2) delete arg2;
9035     }
9036     return resultobj;
9037     fail:
9038     {
9039         if (temp2) delete arg2;
9040     }
9041     return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_TextAttr_SetLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9046     PyObject *resultobj;
9047     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9048     int arg2 ;
9049     int arg3 = (int) 0 ;
9050     PyObject * obj0 = 0 ;
9051     PyObject * obj1 = 0 ;
9052     PyObject * obj2 = 0 ;
9053     char *kwnames[] = {
9054         (char *) "self",(char *) "indent",(char *) "subIndent", NULL
9055     };
9056
9057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetLeftIndent",kwnames,&obj0,&obj1,&obj2)) goto fail;
9058     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9059     if (SWIG_arg_fail(1)) SWIG_fail;
9060     {
9061         arg2 = (int)(SWIG_As_int(obj1));
9062         if (SWIG_arg_fail(2)) SWIG_fail;
9063     }
9064     if (obj2) {
9065         {
9066             arg3 = (int)(SWIG_As_int(obj2));
9067             if (SWIG_arg_fail(3)) SWIG_fail;
9068         }
9069     }
9070     {
9071         PyThreadState* __tstate = wxPyBeginAllowThreads();
9072         (arg1)->SetLeftIndent(arg2,arg3);
9073
9074         wxPyEndAllowThreads(__tstate);
9075         if (PyErr_Occurred()) SWIG_fail;
9076     }
9077     Py_INCREF(Py_None); resultobj = Py_None;
9078     return resultobj;
9079     fail:
9080     return NULL;
9081 }
9082
9083
9084 static PyObject *_wrap_TextAttr_SetRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9085     PyObject *resultobj;
9086     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9087     int arg2 ;
9088     PyObject * obj0 = 0 ;
9089     PyObject * obj1 = 0 ;
9090     char *kwnames[] = {
9091         (char *) "self",(char *) "indent", NULL
9092     };
9093
9094     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetRightIndent",kwnames,&obj0,&obj1)) goto fail;
9095     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9096     if (SWIG_arg_fail(1)) SWIG_fail;
9097     {
9098         arg2 = (int)(SWIG_As_int(obj1));
9099         if (SWIG_arg_fail(2)) SWIG_fail;
9100     }
9101     {
9102         PyThreadState* __tstate = wxPyBeginAllowThreads();
9103         (arg1)->SetRightIndent(arg2);
9104
9105         wxPyEndAllowThreads(__tstate);
9106         if (PyErr_Occurred()) SWIG_fail;
9107     }
9108     Py_INCREF(Py_None); resultobj = Py_None;
9109     return resultobj;
9110     fail:
9111     return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_TextAttr_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9116     PyObject *resultobj;
9117     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9118     long arg2 ;
9119     PyObject * obj0 = 0 ;
9120     PyObject * obj1 = 0 ;
9121     char *kwnames[] = {
9122         (char *) "self",(char *) "flags", NULL
9123     };
9124
9125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9127     if (SWIG_arg_fail(1)) SWIG_fail;
9128     {
9129         arg2 = (long)(SWIG_As_long(obj1));
9130         if (SWIG_arg_fail(2)) SWIG_fail;
9131     }
9132     {
9133         PyThreadState* __tstate = wxPyBeginAllowThreads();
9134         (arg1)->SetFlags(arg2);
9135
9136         wxPyEndAllowThreads(__tstate);
9137         if (PyErr_Occurred()) SWIG_fail;
9138     }
9139     Py_INCREF(Py_None); resultobj = Py_None;
9140     return resultobj;
9141     fail:
9142     return NULL;
9143 }
9144
9145
9146 static PyObject *_wrap_TextAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
9147     PyObject *resultobj;
9148     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9149     bool result;
9150     PyObject * obj0 = 0 ;
9151     char *kwnames[] = {
9152         (char *) "self", NULL
9153     };
9154
9155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasTextColour",kwnames,&obj0)) goto fail;
9156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9157     if (SWIG_arg_fail(1)) SWIG_fail;
9158     {
9159         PyThreadState* __tstate = wxPyBeginAllowThreads();
9160         result = (bool)((wxTextAttr const *)arg1)->HasTextColour();
9161
9162         wxPyEndAllowThreads(__tstate);
9163         if (PyErr_Occurred()) SWIG_fail;
9164     }
9165     {
9166         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9167     }
9168     return resultobj;
9169     fail:
9170     return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_TextAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
9175     PyObject *resultobj;
9176     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9177     bool result;
9178     PyObject * obj0 = 0 ;
9179     char *kwnames[] = {
9180         (char *) "self", NULL
9181     };
9182
9183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
9184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9185     if (SWIG_arg_fail(1)) SWIG_fail;
9186     {
9187         PyThreadState* __tstate = wxPyBeginAllowThreads();
9188         result = (bool)((wxTextAttr const *)arg1)->HasBackgroundColour();
9189
9190         wxPyEndAllowThreads(__tstate);
9191         if (PyErr_Occurred()) SWIG_fail;
9192     }
9193     {
9194         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9195     }
9196     return resultobj;
9197     fail:
9198     return NULL;
9199 }
9200
9201
9202 static PyObject *_wrap_TextAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
9203     PyObject *resultobj;
9204     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9205     bool result;
9206     PyObject * obj0 = 0 ;
9207     char *kwnames[] = {
9208         (char *) "self", NULL
9209     };
9210
9211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasFont",kwnames,&obj0)) goto fail;
9212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9213     if (SWIG_arg_fail(1)) SWIG_fail;
9214     {
9215         PyThreadState* __tstate = wxPyBeginAllowThreads();
9216         result = (bool)((wxTextAttr const *)arg1)->HasFont();
9217
9218         wxPyEndAllowThreads(__tstate);
9219         if (PyErr_Occurred()) SWIG_fail;
9220     }
9221     {
9222         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9223     }
9224     return resultobj;
9225     fail:
9226     return NULL;
9227 }
9228
9229
9230 static PyObject *_wrap_TextAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9231     PyObject *resultobj;
9232     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9233     bool result;
9234     PyObject * obj0 = 0 ;
9235     char *kwnames[] = {
9236         (char *) "self", NULL
9237     };
9238
9239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasAlignment",kwnames,&obj0)) goto fail;
9240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9241     if (SWIG_arg_fail(1)) SWIG_fail;
9242     {
9243         PyThreadState* __tstate = wxPyBeginAllowThreads();
9244         result = (bool)((wxTextAttr const *)arg1)->HasAlignment();
9245
9246         wxPyEndAllowThreads(__tstate);
9247         if (PyErr_Occurred()) SWIG_fail;
9248     }
9249     {
9250         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9251     }
9252     return resultobj;
9253     fail:
9254     return NULL;
9255 }
9256
9257
9258 static PyObject *_wrap_TextAttr_HasTabs(PyObject *, PyObject *args, PyObject *kwargs) {
9259     PyObject *resultobj;
9260     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9261     bool result;
9262     PyObject * obj0 = 0 ;
9263     char *kwnames[] = {
9264         (char *) "self", NULL
9265     };
9266
9267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasTabs",kwnames,&obj0)) goto fail;
9268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9269     if (SWIG_arg_fail(1)) SWIG_fail;
9270     {
9271         PyThreadState* __tstate = wxPyBeginAllowThreads();
9272         result = (bool)((wxTextAttr const *)arg1)->HasTabs();
9273
9274         wxPyEndAllowThreads(__tstate);
9275         if (PyErr_Occurred()) SWIG_fail;
9276     }
9277     {
9278         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9279     }
9280     return resultobj;
9281     fail:
9282     return NULL;
9283 }
9284
9285
9286 static PyObject *_wrap_TextAttr_HasLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9287     PyObject *resultobj;
9288     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9289     bool result;
9290     PyObject * obj0 = 0 ;
9291     char *kwnames[] = {
9292         (char *) "self", NULL
9293     };
9294
9295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasLeftIndent",kwnames,&obj0)) goto fail;
9296     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9297     if (SWIG_arg_fail(1)) SWIG_fail;
9298     {
9299         PyThreadState* __tstate = wxPyBeginAllowThreads();
9300         result = (bool)((wxTextAttr const *)arg1)->HasLeftIndent();
9301
9302         wxPyEndAllowThreads(__tstate);
9303         if (PyErr_Occurred()) SWIG_fail;
9304     }
9305     {
9306         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9307     }
9308     return resultobj;
9309     fail:
9310     return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_TextAttr_HasRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9315     PyObject *resultobj;
9316     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9317     bool result;
9318     PyObject * obj0 = 0 ;
9319     char *kwnames[] = {
9320         (char *) "self", NULL
9321     };
9322
9323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasRightIndent",kwnames,&obj0)) goto fail;
9324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9325     if (SWIG_arg_fail(1)) SWIG_fail;
9326     {
9327         PyThreadState* __tstate = wxPyBeginAllowThreads();
9328         result = (bool)((wxTextAttr const *)arg1)->HasRightIndent();
9329
9330         wxPyEndAllowThreads(__tstate);
9331         if (PyErr_Occurred()) SWIG_fail;
9332     }
9333     {
9334         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9335     }
9336     return resultobj;
9337     fail:
9338     return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_TextAttr_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
9343     PyObject *resultobj;
9344     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9345     long arg2 ;
9346     bool result;
9347     PyObject * obj0 = 0 ;
9348     PyObject * obj1 = 0 ;
9349     char *kwnames[] = {
9350         (char *) "self",(char *) "flag", NULL
9351     };
9352
9353     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_HasFlag",kwnames,&obj0,&obj1)) goto fail;
9354     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9355     if (SWIG_arg_fail(1)) SWIG_fail;
9356     {
9357         arg2 = (long)(SWIG_As_long(obj1));
9358         if (SWIG_arg_fail(2)) SWIG_fail;
9359     }
9360     {
9361         PyThreadState* __tstate = wxPyBeginAllowThreads();
9362         result = (bool)((wxTextAttr const *)arg1)->HasFlag(arg2);
9363
9364         wxPyEndAllowThreads(__tstate);
9365         if (PyErr_Occurred()) SWIG_fail;
9366     }
9367     {
9368         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9369     }
9370     return resultobj;
9371     fail:
9372     return NULL;
9373 }
9374
9375
9376 static PyObject *_wrap_TextAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
9377     PyObject *resultobj;
9378     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9379     wxColour *result;
9380     PyObject * obj0 = 0 ;
9381     char *kwnames[] = {
9382         (char *) "self", NULL
9383     };
9384
9385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetTextColour",kwnames,&obj0)) goto fail;
9386     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9387     if (SWIG_arg_fail(1)) SWIG_fail;
9388     {
9389         PyThreadState* __tstate = wxPyBeginAllowThreads();
9390         {
9391             wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetTextColour();
9392             result = (wxColour *) &_result_ref;
9393         }
9394
9395         wxPyEndAllowThreads(__tstate);
9396         if (PyErr_Occurred()) SWIG_fail;
9397     }
9398     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
9399     return resultobj;
9400     fail:
9401     return NULL;
9402 }
9403
9404
9405 static PyObject *_wrap_TextAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
9406     PyObject *resultobj;
9407     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9408     wxColour *result;
9409     PyObject * obj0 = 0 ;
9410     char *kwnames[] = {
9411         (char *) "self", NULL
9412     };
9413
9414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
9415     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9416     if (SWIG_arg_fail(1)) SWIG_fail;
9417     {
9418         PyThreadState* __tstate = wxPyBeginAllowThreads();
9419         {
9420             wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetBackgroundColour();
9421             result = (wxColour *) &_result_ref;
9422         }
9423
9424         wxPyEndAllowThreads(__tstate);
9425         if (PyErr_Occurred()) SWIG_fail;
9426     }
9427     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
9428     return resultobj;
9429     fail:
9430     return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_TextAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
9435     PyObject *resultobj;
9436     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9437     wxFont *result;
9438     PyObject * obj0 = 0 ;
9439     char *kwnames[] = {
9440         (char *) "self", NULL
9441     };
9442
9443     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetFont",kwnames,&obj0)) goto fail;
9444     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9445     if (SWIG_arg_fail(1)) SWIG_fail;
9446     {
9447         PyThreadState* __tstate = wxPyBeginAllowThreads();
9448         {
9449             wxFont const &_result_ref = ((wxTextAttr const *)arg1)->GetFont();
9450             result = (wxFont *) &_result_ref;
9451         }
9452
9453         wxPyEndAllowThreads(__tstate);
9454         if (PyErr_Occurred()) SWIG_fail;
9455     }
9456     {
9457         wxFont* resultptr = new wxFont(*result);
9458         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
9459     }
9460     return resultobj;
9461     fail:
9462     return NULL;
9463 }
9464
9465
9466 static PyObject *_wrap_TextAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9467     PyObject *resultobj;
9468     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9469     wxTextAttrAlignment result;
9470     PyObject * obj0 = 0 ;
9471     char *kwnames[] = {
9472         (char *) "self", NULL
9473     };
9474
9475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetAlignment",kwnames,&obj0)) goto fail;
9476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9477     if (SWIG_arg_fail(1)) SWIG_fail;
9478     {
9479         PyThreadState* __tstate = wxPyBeginAllowThreads();
9480         result = (wxTextAttrAlignment)((wxTextAttr const *)arg1)->GetAlignment();
9481
9482         wxPyEndAllowThreads(__tstate);
9483         if (PyErr_Occurred()) SWIG_fail;
9484     }
9485     resultobj = SWIG_From_int((result));
9486     return resultobj;
9487     fail:
9488     return NULL;
9489 }
9490
9491
9492 static PyObject *_wrap_TextAttr_GetTabs(PyObject *, PyObject *args, PyObject *kwargs) {
9493     PyObject *resultobj;
9494     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9495     wxArrayInt *result;
9496     PyObject * obj0 = 0 ;
9497     char *kwnames[] = {
9498         (char *) "self", NULL
9499     };
9500
9501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetTabs",kwnames,&obj0)) goto fail;
9502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9503     if (SWIG_arg_fail(1)) SWIG_fail;
9504     {
9505         PyThreadState* __tstate = wxPyBeginAllowThreads();
9506         {
9507             wxArrayInt const &_result_ref = ((wxTextAttr const *)arg1)->GetTabs();
9508             result = (wxArrayInt *) &_result_ref;
9509         }
9510
9511         wxPyEndAllowThreads(__tstate);
9512         if (PyErr_Occurred()) SWIG_fail;
9513     }
9514     {
9515         resultobj = PyList_New(0);
9516         size_t idx;
9517         for (idx = 0; idx < result->GetCount(); idx += 1) {
9518             PyObject* val = PyInt_FromLong( result->Item(idx) );
9519             PyList_Append(resultobj, val);
9520             Py_DECREF(val);
9521         }
9522     }
9523     return resultobj;
9524     fail:
9525     return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_TextAttr_GetLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9530     PyObject *resultobj;
9531     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9532     long result;
9533     PyObject * obj0 = 0 ;
9534     char *kwnames[] = {
9535         (char *) "self", NULL
9536     };
9537
9538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetLeftIndent",kwnames,&obj0)) goto fail;
9539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9540     if (SWIG_arg_fail(1)) SWIG_fail;
9541     {
9542         PyThreadState* __tstate = wxPyBeginAllowThreads();
9543         result = (long)((wxTextAttr const *)arg1)->GetLeftIndent();
9544
9545         wxPyEndAllowThreads(__tstate);
9546         if (PyErr_Occurred()) SWIG_fail;
9547     }
9548     {
9549         resultobj = SWIG_From_long((long)(result));
9550     }
9551     return resultobj;
9552     fail:
9553     return NULL;
9554 }
9555
9556
9557 static PyObject *_wrap_TextAttr_GetLeftSubIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9558     PyObject *resultobj;
9559     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9560     long result;
9561     PyObject * obj0 = 0 ;
9562     char *kwnames[] = {
9563         (char *) "self", NULL
9564     };
9565
9566     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetLeftSubIndent",kwnames,&obj0)) goto fail;
9567     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9568     if (SWIG_arg_fail(1)) SWIG_fail;
9569     {
9570         PyThreadState* __tstate = wxPyBeginAllowThreads();
9571         result = (long)((wxTextAttr const *)arg1)->GetLeftSubIndent();
9572
9573         wxPyEndAllowThreads(__tstate);
9574         if (PyErr_Occurred()) SWIG_fail;
9575     }
9576     {
9577         resultobj = SWIG_From_long((long)(result));
9578     }
9579     return resultobj;
9580     fail:
9581     return NULL;
9582 }
9583
9584
9585 static PyObject *_wrap_TextAttr_GetRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9586     PyObject *resultobj;
9587     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9588     long result;
9589     PyObject * obj0 = 0 ;
9590     char *kwnames[] = {
9591         (char *) "self", NULL
9592     };
9593
9594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetRightIndent",kwnames,&obj0)) goto fail;
9595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9596     if (SWIG_arg_fail(1)) SWIG_fail;
9597     {
9598         PyThreadState* __tstate = wxPyBeginAllowThreads();
9599         result = (long)((wxTextAttr const *)arg1)->GetRightIndent();
9600
9601         wxPyEndAllowThreads(__tstate);
9602         if (PyErr_Occurred()) SWIG_fail;
9603     }
9604     {
9605         resultobj = SWIG_From_long((long)(result));
9606     }
9607     return resultobj;
9608     fail:
9609     return NULL;
9610 }
9611
9612
9613 static PyObject *_wrap_TextAttr_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9614     PyObject *resultobj;
9615     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9616     long result;
9617     PyObject * obj0 = 0 ;
9618     char *kwnames[] = {
9619         (char *) "self", NULL
9620     };
9621
9622     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetFlags",kwnames,&obj0)) goto fail;
9623     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9624     if (SWIG_arg_fail(1)) SWIG_fail;
9625     {
9626         PyThreadState* __tstate = wxPyBeginAllowThreads();
9627         result = (long)((wxTextAttr const *)arg1)->GetFlags();
9628
9629         wxPyEndAllowThreads(__tstate);
9630         if (PyErr_Occurred()) SWIG_fail;
9631     }
9632     {
9633         resultobj = SWIG_From_long((long)(result));
9634     }
9635     return resultobj;
9636     fail:
9637     return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_TextAttr_IsDefault(PyObject *, PyObject *args, PyObject *kwargs) {
9642     PyObject *resultobj;
9643     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9644     bool result;
9645     PyObject * obj0 = 0 ;
9646     char *kwnames[] = {
9647         (char *) "self", NULL
9648     };
9649
9650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_IsDefault",kwnames,&obj0)) goto fail;
9651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9652     if (SWIG_arg_fail(1)) SWIG_fail;
9653     {
9654         PyThreadState* __tstate = wxPyBeginAllowThreads();
9655         result = (bool)((wxTextAttr const *)arg1)->IsDefault();
9656
9657         wxPyEndAllowThreads(__tstate);
9658         if (PyErr_Occurred()) SWIG_fail;
9659     }
9660     {
9661         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9662     }
9663     return resultobj;
9664     fail:
9665     return NULL;
9666 }
9667
9668
9669 static PyObject *_wrap_TextAttr_Combine(PyObject *, PyObject *args, PyObject *kwargs) {
9670     PyObject *resultobj;
9671     wxTextAttr *arg1 = 0 ;
9672     wxTextAttr *arg2 = 0 ;
9673     wxTextCtrl *arg3 = (wxTextCtrl *) 0 ;
9674     wxTextAttr result;
9675     PyObject * obj0 = 0 ;
9676     PyObject * obj1 = 0 ;
9677     PyObject * obj2 = 0 ;
9678     char *kwnames[] = {
9679         (char *) "attr",(char *) "attrDef",(char *) "text", NULL
9680     };
9681
9682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttr_Combine",kwnames,&obj0,&obj1,&obj2)) goto fail;
9683     {
9684         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9685         if (SWIG_arg_fail(1)) SWIG_fail;
9686         if (arg1 == NULL) {
9687             SWIG_null_ref("wxTextAttr");
9688         }
9689         if (SWIG_arg_fail(1)) SWIG_fail;
9690     }
9691     {
9692         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9693         if (SWIG_arg_fail(2)) SWIG_fail;
9694         if (arg2 == NULL) {
9695             SWIG_null_ref("wxTextAttr");
9696         }
9697         if (SWIG_arg_fail(2)) SWIG_fail;
9698     }
9699     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9700     if (SWIG_arg_fail(3)) SWIG_fail;
9701     {
9702         PyThreadState* __tstate = wxPyBeginAllowThreads();
9703         result = wxTextAttr::Combine((wxTextAttr const &)*arg1,(wxTextAttr const &)*arg2,(wxTextCtrl const *)arg3);
9704
9705         wxPyEndAllowThreads(__tstate);
9706         if (PyErr_Occurred()) SWIG_fail;
9707     }
9708     {
9709         wxTextAttr * resultptr;
9710         resultptr = new wxTextAttr((wxTextAttr &)(result));
9711         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTextAttr, 1);
9712     }
9713     return resultobj;
9714     fail:
9715     return NULL;
9716 }
9717
9718
9719 static PyObject * TextAttr_swigregister(PyObject *, PyObject *args) {
9720     PyObject *obj;
9721     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9722     SWIG_TypeClientData(SWIGTYPE_p_wxTextAttr, obj);
9723     Py_INCREF(obj);
9724     return Py_BuildValue((char *)"");
9725 }
9726 static PyObject *_wrap_new_TextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9727     PyObject *resultobj;
9728     wxWindow *arg1 = (wxWindow *) 0 ;
9729     int arg2 = (int) -1 ;
9730     wxString const &arg3_defvalue = wxPyEmptyString ;
9731     wxString *arg3 = (wxString *) &arg3_defvalue ;
9732     wxPoint const &arg4_defvalue = wxDefaultPosition ;
9733     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9734     wxSize const &arg5_defvalue = wxDefaultSize ;
9735     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9736     long arg6 = (long) 0 ;
9737     wxValidator const &arg7_defvalue = wxDefaultValidator ;
9738     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
9739     wxString const &arg8_defvalue = wxPyTextCtrlNameStr ;
9740     wxString *arg8 = (wxString *) &arg8_defvalue ;
9741     wxTextCtrl *result;
9742     bool temp3 = false ;
9743     wxPoint temp4 ;
9744     wxSize temp5 ;
9745     bool temp8 = false ;
9746     PyObject * obj0 = 0 ;
9747     PyObject * obj1 = 0 ;
9748     PyObject * obj2 = 0 ;
9749     PyObject * obj3 = 0 ;
9750     PyObject * obj4 = 0 ;
9751     PyObject * obj5 = 0 ;
9752     PyObject * obj6 = 0 ;
9753     PyObject * obj7 = 0 ;
9754     char *kwnames[] = {
9755         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
9756     };
9757
9758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_TextCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
9759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9760     if (SWIG_arg_fail(1)) SWIG_fail;
9761     if (obj1) {
9762         {
9763             arg2 = (int)(SWIG_As_int(obj1));
9764             if (SWIG_arg_fail(2)) SWIG_fail;
9765         }
9766     }
9767     if (obj2) {
9768         {
9769             arg3 = wxString_in_helper(obj2);
9770             if (arg3 == NULL) SWIG_fail;
9771             temp3 = true;
9772         }
9773     }
9774     if (obj3) {
9775         {
9776             arg4 = &temp4;
9777             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9778         }
9779     }
9780     if (obj4) {
9781         {
9782             arg5 = &temp5;
9783             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9784         }
9785     }
9786     if (obj5) {
9787         {
9788             arg6 = (long)(SWIG_As_long(obj5));
9789             if (SWIG_arg_fail(6)) SWIG_fail;
9790         }
9791     }
9792     if (obj6) {
9793         {
9794             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
9795             if (SWIG_arg_fail(7)) SWIG_fail;
9796             if (arg7 == NULL) {
9797                 SWIG_null_ref("wxValidator");
9798             }
9799             if (SWIG_arg_fail(7)) SWIG_fail;
9800         }
9801     }
9802     if (obj7) {
9803         {
9804             arg8 = wxString_in_helper(obj7);
9805             if (arg8 == NULL) SWIG_fail;
9806             temp8 = true;
9807         }
9808     }
9809     {
9810         if (!wxPyCheckForApp()) SWIG_fail;
9811         PyThreadState* __tstate = wxPyBeginAllowThreads();
9812         result = (wxTextCtrl *)new wxTextCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
9813
9814         wxPyEndAllowThreads(__tstate);
9815         if (PyErr_Occurred()) SWIG_fail;
9816     }
9817     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextCtrl, 1);
9818     {
9819         if (temp3)
9820         delete arg3;
9821     }
9822     {
9823         if (temp8)
9824         delete arg8;
9825     }
9826     return resultobj;
9827     fail:
9828     {
9829         if (temp3)
9830         delete arg3;
9831     }
9832     {
9833         if (temp8)
9834         delete arg8;
9835     }
9836     return NULL;
9837 }
9838
9839
9840 static PyObject *_wrap_new_PreTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9841     PyObject *resultobj;
9842     wxTextCtrl *result;
9843     char *kwnames[] = {
9844         NULL
9845     };
9846
9847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreTextCtrl",kwnames)) goto fail;
9848     {
9849         if (!wxPyCheckForApp()) SWIG_fail;
9850         PyThreadState* __tstate = wxPyBeginAllowThreads();
9851         result = (wxTextCtrl *)new wxTextCtrl();
9852
9853         wxPyEndAllowThreads(__tstate);
9854         if (PyErr_Occurred()) SWIG_fail;
9855     }
9856     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextCtrl, 1);
9857     return resultobj;
9858     fail:
9859     return NULL;
9860 }
9861
9862
9863 static PyObject *_wrap_TextCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9864     PyObject *resultobj;
9865     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9866     wxWindow *arg2 = (wxWindow *) 0 ;
9867     int arg3 = (int) -1 ;
9868     wxString const &arg4_defvalue = wxPyEmptyString ;
9869     wxString *arg4 = (wxString *) &arg4_defvalue ;
9870     wxPoint const &arg5_defvalue = wxDefaultPosition ;
9871     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
9872     wxSize const &arg6_defvalue = wxDefaultSize ;
9873     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
9874     long arg7 = (long) 0 ;
9875     wxValidator const &arg8_defvalue = wxDefaultValidator ;
9876     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
9877     wxString const &arg9_defvalue = wxPyTextCtrlNameStr ;
9878     wxString *arg9 = (wxString *) &arg9_defvalue ;
9879     bool result;
9880     bool temp4 = false ;
9881     wxPoint temp5 ;
9882     wxSize temp6 ;
9883     bool temp9 = false ;
9884     PyObject * obj0 = 0 ;
9885     PyObject * obj1 = 0 ;
9886     PyObject * obj2 = 0 ;
9887     PyObject * obj3 = 0 ;
9888     PyObject * obj4 = 0 ;
9889     PyObject * obj5 = 0 ;
9890     PyObject * obj6 = 0 ;
9891     PyObject * obj7 = 0 ;
9892     PyObject * obj8 = 0 ;
9893     char *kwnames[] = {
9894         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
9895     };
9896
9897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:TextCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
9898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9899     if (SWIG_arg_fail(1)) SWIG_fail;
9900     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9901     if (SWIG_arg_fail(2)) SWIG_fail;
9902     if (obj2) {
9903         {
9904             arg3 = (int)(SWIG_As_int(obj2));
9905             if (SWIG_arg_fail(3)) SWIG_fail;
9906         }
9907     }
9908     if (obj3) {
9909         {
9910             arg4 = wxString_in_helper(obj3);
9911             if (arg4 == NULL) SWIG_fail;
9912             temp4 = true;
9913         }
9914     }
9915     if (obj4) {
9916         {
9917             arg5 = &temp5;
9918             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
9919         }
9920     }
9921     if (obj5) {
9922         {
9923             arg6 = &temp6;
9924             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
9925         }
9926     }
9927     if (obj6) {
9928         {
9929             arg7 = (long)(SWIG_As_long(obj6));
9930             if (SWIG_arg_fail(7)) SWIG_fail;
9931         }
9932     }
9933     if (obj7) {
9934         {
9935             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
9936             if (SWIG_arg_fail(8)) SWIG_fail;
9937             if (arg8 == NULL) {
9938                 SWIG_null_ref("wxValidator");
9939             }
9940             if (SWIG_arg_fail(8)) SWIG_fail;
9941         }
9942     }
9943     if (obj8) {
9944         {
9945             arg9 = wxString_in_helper(obj8);
9946             if (arg9 == NULL) SWIG_fail;
9947             temp9 = true;
9948         }
9949     }
9950     {
9951         PyThreadState* __tstate = wxPyBeginAllowThreads();
9952         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
9953
9954         wxPyEndAllowThreads(__tstate);
9955         if (PyErr_Occurred()) SWIG_fail;
9956     }
9957     {
9958         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9959     }
9960     {
9961         if (temp4)
9962         delete arg4;
9963     }
9964     {
9965         if (temp9)
9966         delete arg9;
9967     }
9968     return resultobj;
9969     fail:
9970     {
9971         if (temp4)
9972         delete arg4;
9973     }
9974     {
9975         if (temp9)
9976         delete arg9;
9977     }
9978     return NULL;
9979 }
9980
9981
9982 static PyObject *_wrap_TextCtrl_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
9983     PyObject *resultobj;
9984     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9985     wxString result;
9986     PyObject * obj0 = 0 ;
9987     char *kwnames[] = {
9988         (char *) "self", NULL
9989     };
9990
9991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetValue",kwnames,&obj0)) goto fail;
9992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9993     if (SWIG_arg_fail(1)) SWIG_fail;
9994     {
9995         PyThreadState* __tstate = wxPyBeginAllowThreads();
9996         result = ((wxTextCtrl const *)arg1)->GetValue();
9997
9998         wxPyEndAllowThreads(__tstate);
9999         if (PyErr_Occurred()) SWIG_fail;
10000     }
10001     {
10002 #if wxUSE_UNICODE
10003         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10004 #else
10005         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10006 #endif
10007     }
10008     return resultobj;
10009     fail:
10010     return NULL;
10011 }
10012
10013
10014 static PyObject *_wrap_TextCtrl_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
10015     PyObject *resultobj;
10016     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10017     wxString *arg2 = 0 ;
10018     bool temp2 = false ;
10019     PyObject * obj0 = 0 ;
10020     PyObject * obj1 = 0 ;
10021     char *kwnames[] = {
10022         (char *) "self",(char *) "value", NULL
10023     };
10024
10025     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetValue",kwnames,&obj0,&obj1)) goto fail;
10026     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10027     if (SWIG_arg_fail(1)) SWIG_fail;
10028     {
10029         arg2 = wxString_in_helper(obj1);
10030         if (arg2 == NULL) SWIG_fail;
10031         temp2 = true;
10032     }
10033     {
10034         PyThreadState* __tstate = wxPyBeginAllowThreads();
10035         (arg1)->SetValue((wxString const &)*arg2);
10036
10037         wxPyEndAllowThreads(__tstate);
10038         if (PyErr_Occurred()) SWIG_fail;
10039     }
10040     Py_INCREF(Py_None); resultobj = Py_None;
10041     {
10042         if (temp2)
10043         delete arg2;
10044     }
10045     return resultobj;
10046     fail:
10047     {
10048         if (temp2)
10049         delete arg2;
10050     }
10051     return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_TextCtrl_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
10056     PyObject *resultobj;
10057     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10058     long arg2 ;
10059     long arg3 ;
10060     wxString result;
10061     PyObject * obj0 = 0 ;
10062     PyObject * obj1 = 0 ;
10063     PyObject * obj2 = 0 ;
10064     char *kwnames[] = {
10065         (char *) "self",(char *) "from",(char *) "to", NULL
10066     };
10067
10068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
10069     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10070     if (SWIG_arg_fail(1)) SWIG_fail;
10071     {
10072         arg2 = (long)(SWIG_As_long(obj1));
10073         if (SWIG_arg_fail(2)) SWIG_fail;
10074     }
10075     {
10076         arg3 = (long)(SWIG_As_long(obj2));
10077         if (SWIG_arg_fail(3)) SWIG_fail;
10078     }
10079     {
10080         PyThreadState* __tstate = wxPyBeginAllowThreads();
10081         result = ((wxTextCtrl const *)arg1)->GetRange(arg2,arg3);
10082
10083         wxPyEndAllowThreads(__tstate);
10084         if (PyErr_Occurred()) SWIG_fail;
10085     }
10086     {
10087 #if wxUSE_UNICODE
10088         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10089 #else
10090         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10091 #endif
10092     }
10093     return resultobj;
10094     fail:
10095     return NULL;
10096 }
10097
10098
10099 static PyObject *_wrap_TextCtrl_GetLineLength(PyObject *, PyObject *args, PyObject *kwargs) {
10100     PyObject *resultobj;
10101     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10102     long arg2 ;
10103     int result;
10104     PyObject * obj0 = 0 ;
10105     PyObject * obj1 = 0 ;
10106     char *kwnames[] = {
10107         (char *) "self",(char *) "lineNo", NULL
10108     };
10109
10110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_GetLineLength",kwnames,&obj0,&obj1)) goto fail;
10111     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10112     if (SWIG_arg_fail(1)) SWIG_fail;
10113     {
10114         arg2 = (long)(SWIG_As_long(obj1));
10115         if (SWIG_arg_fail(2)) SWIG_fail;
10116     }
10117     {
10118         PyThreadState* __tstate = wxPyBeginAllowThreads();
10119         result = (int)((wxTextCtrl const *)arg1)->GetLineLength(arg2);
10120
10121         wxPyEndAllowThreads(__tstate);
10122         if (PyErr_Occurred()) SWIG_fail;
10123     }
10124     {
10125         resultobj = SWIG_From_int((int)(result));
10126     }
10127     return resultobj;
10128     fail:
10129     return NULL;
10130 }
10131
10132
10133 static PyObject *_wrap_TextCtrl_GetLineText(PyObject *, PyObject *args, PyObject *kwargs) {
10134     PyObject *resultobj;
10135     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10136     long arg2 ;
10137     wxString result;
10138     PyObject * obj0 = 0 ;
10139     PyObject * obj1 = 0 ;
10140     char *kwnames[] = {
10141         (char *) "self",(char *) "lineNo", NULL
10142     };
10143
10144     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_GetLineText",kwnames,&obj0,&obj1)) goto fail;
10145     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10146     if (SWIG_arg_fail(1)) SWIG_fail;
10147     {
10148         arg2 = (long)(SWIG_As_long(obj1));
10149         if (SWIG_arg_fail(2)) SWIG_fail;
10150     }
10151     {
10152         PyThreadState* __tstate = wxPyBeginAllowThreads();
10153         result = ((wxTextCtrl const *)arg1)->GetLineText(arg2);
10154
10155         wxPyEndAllowThreads(__tstate);
10156         if (PyErr_Occurred()) SWIG_fail;
10157     }
10158     {
10159 #if wxUSE_UNICODE
10160         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10161 #else
10162         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10163 #endif
10164     }
10165     return resultobj;
10166     fail:
10167     return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_TextCtrl_GetNumberOfLines(PyObject *, PyObject *args, PyObject *kwargs) {
10172     PyObject *resultobj;
10173     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10174     int result;
10175     PyObject * obj0 = 0 ;
10176     char *kwnames[] = {
10177         (char *) "self", NULL
10178     };
10179
10180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetNumberOfLines",kwnames,&obj0)) goto fail;
10181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10182     if (SWIG_arg_fail(1)) SWIG_fail;
10183     {
10184         PyThreadState* __tstate = wxPyBeginAllowThreads();
10185         result = (int)((wxTextCtrl const *)arg1)->GetNumberOfLines();
10186
10187         wxPyEndAllowThreads(__tstate);
10188         if (PyErr_Occurred()) SWIG_fail;
10189     }
10190     {
10191         resultobj = SWIG_From_int((int)(result));
10192     }
10193     return resultobj;
10194     fail:
10195     return NULL;
10196 }
10197
10198
10199 static PyObject *_wrap_TextCtrl_IsModified(PyObject *, PyObject *args, PyObject *kwargs) {
10200     PyObject *resultobj;
10201     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10202     bool result;
10203     PyObject * obj0 = 0 ;
10204     char *kwnames[] = {
10205         (char *) "self", NULL
10206     };
10207
10208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsModified",kwnames,&obj0)) goto fail;
10209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10210     if (SWIG_arg_fail(1)) SWIG_fail;
10211     {
10212         PyThreadState* __tstate = wxPyBeginAllowThreads();
10213         result = (bool)((wxTextCtrl const *)arg1)->IsModified();
10214
10215         wxPyEndAllowThreads(__tstate);
10216         if (PyErr_Occurred()) SWIG_fail;
10217     }
10218     {
10219         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10220     }
10221     return resultobj;
10222     fail:
10223     return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_TextCtrl_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10228     PyObject *resultobj;
10229     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10230     bool result;
10231     PyObject * obj0 = 0 ;
10232     char *kwnames[] = {
10233         (char *) "self", NULL
10234     };
10235
10236     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsEditable",kwnames,&obj0)) goto fail;
10237     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10238     if (SWIG_arg_fail(1)) SWIG_fail;
10239     {
10240         PyThreadState* __tstate = wxPyBeginAllowThreads();
10241         result = (bool)((wxTextCtrl const *)arg1)->IsEditable();
10242
10243         wxPyEndAllowThreads(__tstate);
10244         if (PyErr_Occurred()) SWIG_fail;
10245     }
10246     {
10247         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10248     }
10249     return resultobj;
10250     fail:
10251     return NULL;
10252 }
10253
10254
10255 static PyObject *_wrap_TextCtrl_IsSingleLine(PyObject *, PyObject *args, PyObject *kwargs) {
10256     PyObject *resultobj;
10257     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10258     bool result;
10259     PyObject * obj0 = 0 ;
10260     char *kwnames[] = {
10261         (char *) "self", NULL
10262     };
10263
10264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsSingleLine",kwnames,&obj0)) goto fail;
10265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10266     if (SWIG_arg_fail(1)) SWIG_fail;
10267     {
10268         PyThreadState* __tstate = wxPyBeginAllowThreads();
10269         result = (bool)((wxTextCtrl const *)arg1)->IsSingleLine();
10270
10271         wxPyEndAllowThreads(__tstate);
10272         if (PyErr_Occurred()) SWIG_fail;
10273     }
10274     {
10275         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10276     }
10277     return resultobj;
10278     fail:
10279     return NULL;
10280 }
10281
10282
10283 static PyObject *_wrap_TextCtrl_IsMultiLine(PyObject *, PyObject *args, PyObject *kwargs) {
10284     PyObject *resultobj;
10285     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10286     bool result;
10287     PyObject * obj0 = 0 ;
10288     char *kwnames[] = {
10289         (char *) "self", NULL
10290     };
10291
10292     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsMultiLine",kwnames,&obj0)) goto fail;
10293     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10294     if (SWIG_arg_fail(1)) SWIG_fail;
10295     {
10296         PyThreadState* __tstate = wxPyBeginAllowThreads();
10297         result = (bool)((wxTextCtrl const *)arg1)->IsMultiLine();
10298
10299         wxPyEndAllowThreads(__tstate);
10300         if (PyErr_Occurred()) SWIG_fail;
10301     }
10302     {
10303         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10304     }
10305     return resultobj;
10306     fail:
10307     return NULL;
10308 }
10309
10310
10311 static PyObject *_wrap_TextCtrl_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
10312     PyObject *resultobj;
10313     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10314     long *arg2 = (long *) 0 ;
10315     long *arg3 = (long *) 0 ;
10316     long temp2 ;
10317     int res2 = 0 ;
10318     long temp3 ;
10319     int res3 = 0 ;
10320     PyObject * obj0 = 0 ;
10321     char *kwnames[] = {
10322         (char *) "self", NULL
10323     };
10324
10325     arg2 = &temp2; res2 = SWIG_NEWOBJ;
10326     arg3 = &temp3; res3 = SWIG_NEWOBJ;
10327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetSelection",kwnames,&obj0)) goto fail;
10328     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10329     if (SWIG_arg_fail(1)) SWIG_fail;
10330     {
10331         PyThreadState* __tstate = wxPyBeginAllowThreads();
10332         ((wxTextCtrl const *)arg1)->GetSelection(arg2,arg3);
10333
10334         wxPyEndAllowThreads(__tstate);
10335         if (PyErr_Occurred()) SWIG_fail;
10336     }
10337     Py_INCREF(Py_None); resultobj = Py_None;
10338     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10339     SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
10340     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10341     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
10342     return resultobj;
10343     fail:
10344     return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_TextCtrl_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
10349     PyObject *resultobj;
10350     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10351     wxString result;
10352     PyObject * obj0 = 0 ;
10353     char *kwnames[] = {
10354         (char *) "self", NULL
10355     };
10356
10357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetStringSelection",kwnames,&obj0)) goto fail;
10358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10359     if (SWIG_arg_fail(1)) SWIG_fail;
10360     {
10361         PyThreadState* __tstate = wxPyBeginAllowThreads();
10362         result = ((wxTextCtrl const *)arg1)->GetStringSelection();
10363
10364         wxPyEndAllowThreads(__tstate);
10365         if (PyErr_Occurred()) SWIG_fail;
10366     }
10367     {
10368 #if wxUSE_UNICODE
10369         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10370 #else
10371         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10372 #endif
10373     }
10374     return resultobj;
10375     fail:
10376     return NULL;
10377 }
10378
10379
10380 static PyObject *_wrap_TextCtrl_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
10381     PyObject *resultobj;
10382     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10383     PyObject * obj0 = 0 ;
10384     char *kwnames[] = {
10385         (char *) "self", NULL
10386     };
10387
10388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Clear",kwnames,&obj0)) goto fail;
10389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10390     if (SWIG_arg_fail(1)) SWIG_fail;
10391     {
10392         PyThreadState* __tstate = wxPyBeginAllowThreads();
10393         (arg1)->Clear();
10394
10395         wxPyEndAllowThreads(__tstate);
10396         if (PyErr_Occurred()) SWIG_fail;
10397     }
10398     Py_INCREF(Py_None); resultobj = Py_None;
10399     return resultobj;
10400     fail:
10401     return NULL;
10402 }
10403
10404
10405 static PyObject *_wrap_TextCtrl_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
10406     PyObject *resultobj;
10407     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10408     long arg2 ;
10409     long arg3 ;
10410     wxString *arg4 = 0 ;
10411     bool temp4 = false ;
10412     PyObject * obj0 = 0 ;
10413     PyObject * obj1 = 0 ;
10414     PyObject * obj2 = 0 ;
10415     PyObject * obj3 = 0 ;
10416     char *kwnames[] = {
10417         (char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL
10418     };
10419
10420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextCtrl_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10421     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10422     if (SWIG_arg_fail(1)) SWIG_fail;
10423     {
10424         arg2 = (long)(SWIG_As_long(obj1));
10425         if (SWIG_arg_fail(2)) SWIG_fail;
10426     }
10427     {
10428         arg3 = (long)(SWIG_As_long(obj2));
10429         if (SWIG_arg_fail(3)) SWIG_fail;
10430     }
10431     {
10432         arg4 = wxString_in_helper(obj3);
10433         if (arg4 == NULL) SWIG_fail;
10434         temp4 = true;
10435     }
10436     {
10437         PyThreadState* __tstate = wxPyBeginAllowThreads();
10438         (arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
10439
10440         wxPyEndAllowThreads(__tstate);
10441         if (PyErr_Occurred()) SWIG_fail;
10442     }
10443     Py_INCREF(Py_None); resultobj = Py_None;
10444     {
10445         if (temp4)
10446         delete arg4;
10447     }
10448     return resultobj;
10449     fail:
10450     {
10451         if (temp4)
10452         delete arg4;
10453     }
10454     return NULL;
10455 }
10456
10457
10458 static PyObject *_wrap_TextCtrl_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
10459     PyObject *resultobj;
10460     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10461     long arg2 ;
10462     long arg3 ;
10463     PyObject * obj0 = 0 ;
10464     PyObject * obj1 = 0 ;
10465     PyObject * obj2 = 0 ;
10466     char *kwnames[] = {
10467         (char *) "self",(char *) "from",(char *) "to", NULL
10468     };
10469
10470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_Remove",kwnames,&obj0,&obj1,&obj2)) goto fail;
10471     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10472     if (SWIG_arg_fail(1)) SWIG_fail;
10473     {
10474         arg2 = (long)(SWIG_As_long(obj1));
10475         if (SWIG_arg_fail(2)) SWIG_fail;
10476     }
10477     {
10478         arg3 = (long)(SWIG_As_long(obj2));
10479         if (SWIG_arg_fail(3)) SWIG_fail;
10480     }
10481     {
10482         PyThreadState* __tstate = wxPyBeginAllowThreads();
10483         (arg1)->Remove(arg2,arg3);
10484
10485         wxPyEndAllowThreads(__tstate);
10486         if (PyErr_Occurred()) SWIG_fail;
10487     }
10488     Py_INCREF(Py_None); resultobj = Py_None;
10489     return resultobj;
10490     fail:
10491     return NULL;
10492 }
10493
10494
10495 static PyObject *_wrap_TextCtrl_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
10496     PyObject *resultobj;
10497     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10498     wxString *arg2 = 0 ;
10499     bool result;
10500     bool temp2 = false ;
10501     PyObject * obj0 = 0 ;
10502     PyObject * obj1 = 0 ;
10503     char *kwnames[] = {
10504         (char *) "self",(char *) "file", NULL
10505     };
10506
10507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_LoadFile",kwnames,&obj0,&obj1)) goto fail;
10508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10509     if (SWIG_arg_fail(1)) SWIG_fail;
10510     {
10511         arg2 = wxString_in_helper(obj1);
10512         if (arg2 == NULL) SWIG_fail;
10513         temp2 = true;
10514     }
10515     {
10516         PyThreadState* __tstate = wxPyBeginAllowThreads();
10517         result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
10518
10519         wxPyEndAllowThreads(__tstate);
10520         if (PyErr_Occurred()) SWIG_fail;
10521     }
10522     {
10523         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10524     }
10525     {
10526         if (temp2)
10527         delete arg2;
10528     }
10529     return resultobj;
10530     fail:
10531     {
10532         if (temp2)
10533         delete arg2;
10534     }
10535     return NULL;
10536 }
10537
10538
10539 static PyObject *_wrap_TextCtrl_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
10540     PyObject *resultobj;
10541     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10542     wxString const &arg2_defvalue = wxPyEmptyString ;
10543     wxString *arg2 = (wxString *) &arg2_defvalue ;
10544     bool result;
10545     bool temp2 = false ;
10546     PyObject * obj0 = 0 ;
10547     PyObject * obj1 = 0 ;
10548     char *kwnames[] = {
10549         (char *) "self",(char *) "file", NULL
10550     };
10551
10552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TextCtrl_SaveFile",kwnames,&obj0,&obj1)) goto fail;
10553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10554     if (SWIG_arg_fail(1)) SWIG_fail;
10555     if (obj1) {
10556         {
10557             arg2 = wxString_in_helper(obj1);
10558             if (arg2 == NULL) SWIG_fail;
10559             temp2 = true;
10560         }
10561     }
10562     {
10563         PyThreadState* __tstate = wxPyBeginAllowThreads();
10564         result = (bool)(arg1)->SaveFile((wxString const &)*arg2);
10565
10566         wxPyEndAllowThreads(__tstate);
10567         if (PyErr_Occurred()) SWIG_fail;
10568     }
10569     {
10570         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10571     }
10572     {
10573         if (temp2)
10574         delete arg2;
10575     }
10576     return resultobj;
10577     fail:
10578     {
10579         if (temp2)
10580         delete arg2;
10581     }
10582     return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_TextCtrl_MarkDirty(PyObject *, PyObject *args, PyObject *kwargs) {
10587     PyObject *resultobj;
10588     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10589     PyObject * obj0 = 0 ;
10590     char *kwnames[] = {
10591         (char *) "self", NULL
10592     };
10593
10594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_MarkDirty",kwnames,&obj0)) goto fail;
10595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10596     if (SWIG_arg_fail(1)) SWIG_fail;
10597     {
10598         PyThreadState* __tstate = wxPyBeginAllowThreads();
10599         (arg1)->MarkDirty();
10600
10601         wxPyEndAllowThreads(__tstate);
10602         if (PyErr_Occurred()) SWIG_fail;
10603     }
10604     Py_INCREF(Py_None); resultobj = Py_None;
10605     return resultobj;
10606     fail:
10607     return NULL;
10608 }
10609
10610
10611 static PyObject *_wrap_TextCtrl_DiscardEdits(PyObject *, PyObject *args, PyObject *kwargs) {
10612     PyObject *resultobj;
10613     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10614     PyObject * obj0 = 0 ;
10615     char *kwnames[] = {
10616         (char *) "self", NULL
10617     };
10618
10619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_DiscardEdits",kwnames,&obj0)) goto fail;
10620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10621     if (SWIG_arg_fail(1)) SWIG_fail;
10622     {
10623         PyThreadState* __tstate = wxPyBeginAllowThreads();
10624         (arg1)->DiscardEdits();
10625
10626         wxPyEndAllowThreads(__tstate);
10627         if (PyErr_Occurred()) SWIG_fail;
10628     }
10629     Py_INCREF(Py_None); resultobj = Py_None;
10630     return resultobj;
10631     fail:
10632     return NULL;
10633 }
10634
10635
10636 static PyObject *_wrap_TextCtrl_SetMaxLength(PyObject *, PyObject *args, PyObject *kwargs) {
10637     PyObject *resultobj;
10638     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10639     unsigned long arg2 ;
10640     PyObject * obj0 = 0 ;
10641     PyObject * obj1 = 0 ;
10642     char *kwnames[] = {
10643         (char *) "self",(char *) "len", NULL
10644     };
10645
10646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetMaxLength",kwnames,&obj0,&obj1)) goto fail;
10647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10648     if (SWIG_arg_fail(1)) SWIG_fail;
10649     {
10650         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10651         if (SWIG_arg_fail(2)) SWIG_fail;
10652     }
10653     {
10654         PyThreadState* __tstate = wxPyBeginAllowThreads();
10655         (arg1)->SetMaxLength(arg2);
10656
10657         wxPyEndAllowThreads(__tstate);
10658         if (PyErr_Occurred()) SWIG_fail;
10659     }
10660     Py_INCREF(Py_None); resultobj = Py_None;
10661     return resultobj;
10662     fail:
10663     return NULL;
10664 }
10665
10666
10667 static PyObject *_wrap_TextCtrl_WriteText(PyObject *, PyObject *args, PyObject *kwargs) {
10668     PyObject *resultobj;
10669     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10670     wxString *arg2 = 0 ;
10671     bool temp2 = false ;
10672     PyObject * obj0 = 0 ;
10673     PyObject * obj1 = 0 ;
10674     char *kwnames[] = {
10675         (char *) "self",(char *) "text", NULL
10676     };
10677
10678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_WriteText",kwnames,&obj0,&obj1)) goto fail;
10679     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10680     if (SWIG_arg_fail(1)) SWIG_fail;
10681     {
10682         arg2 = wxString_in_helper(obj1);
10683         if (arg2 == NULL) SWIG_fail;
10684         temp2 = true;
10685     }
10686     {
10687         PyThreadState* __tstate = wxPyBeginAllowThreads();
10688         (arg1)->WriteText((wxString const &)*arg2);
10689
10690         wxPyEndAllowThreads(__tstate);
10691         if (PyErr_Occurred()) SWIG_fail;
10692     }
10693     Py_INCREF(Py_None); resultobj = Py_None;
10694     {
10695         if (temp2)
10696         delete arg2;
10697     }
10698     return resultobj;
10699     fail:
10700     {
10701         if (temp2)
10702         delete arg2;
10703     }
10704     return NULL;
10705 }
10706
10707
10708 static PyObject *_wrap_TextCtrl_AppendText(PyObject *, PyObject *args, PyObject *kwargs) {
10709     PyObject *resultobj;
10710     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10711     wxString *arg2 = 0 ;
10712     bool temp2 = false ;
10713     PyObject * obj0 = 0 ;
10714     PyObject * obj1 = 0 ;
10715     char *kwnames[] = {
10716         (char *) "self",(char *) "text", NULL
10717     };
10718
10719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_AppendText",kwnames,&obj0,&obj1)) goto fail;
10720     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10721     if (SWIG_arg_fail(1)) SWIG_fail;
10722     {
10723         arg2 = wxString_in_helper(obj1);
10724         if (arg2 == NULL) SWIG_fail;
10725         temp2 = true;
10726     }
10727     {
10728         PyThreadState* __tstate = wxPyBeginAllowThreads();
10729         (arg1)->AppendText((wxString const &)*arg2);
10730
10731         wxPyEndAllowThreads(__tstate);
10732         if (PyErr_Occurred()) SWIG_fail;
10733     }
10734     Py_INCREF(Py_None); resultobj = Py_None;
10735     {
10736         if (temp2)
10737         delete arg2;
10738     }
10739     return resultobj;
10740     fail:
10741     {
10742         if (temp2)
10743         delete arg2;
10744     }
10745     return NULL;
10746 }
10747
10748
10749 static PyObject *_wrap_TextCtrl_EmulateKeyPress(PyObject *, PyObject *args, PyObject *kwargs) {
10750     PyObject *resultobj;
10751     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10752     wxKeyEvent *arg2 = 0 ;
10753     bool result;
10754     PyObject * obj0 = 0 ;
10755     PyObject * obj1 = 0 ;
10756     char *kwnames[] = {
10757         (char *) "self",(char *) "event", NULL
10758     };
10759
10760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_EmulateKeyPress",kwnames,&obj0,&obj1)) goto fail;
10761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10762     if (SWIG_arg_fail(1)) SWIG_fail;
10763     {
10764         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
10765         if (SWIG_arg_fail(2)) SWIG_fail;
10766         if (arg2 == NULL) {
10767             SWIG_null_ref("wxKeyEvent");
10768         }
10769         if (SWIG_arg_fail(2)) SWIG_fail;
10770     }
10771     {
10772         PyThreadState* __tstate = wxPyBeginAllowThreads();
10773         result = (bool)(arg1)->EmulateKeyPress((wxKeyEvent const &)*arg2);
10774
10775         wxPyEndAllowThreads(__tstate);
10776         if (PyErr_Occurred()) SWIG_fail;
10777     }
10778     {
10779         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10780     }
10781     return resultobj;
10782     fail:
10783     return NULL;
10784 }
10785
10786
10787 static PyObject *_wrap_TextCtrl_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10788     PyObject *resultobj;
10789     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10790     long arg2 ;
10791     long arg3 ;
10792     wxTextAttr *arg4 = 0 ;
10793     bool result;
10794     PyObject * obj0 = 0 ;
10795     PyObject * obj1 = 0 ;
10796     PyObject * obj2 = 0 ;
10797     PyObject * obj3 = 0 ;
10798     char *kwnames[] = {
10799         (char *) "self",(char *) "start",(char *) "end",(char *) "style", NULL
10800     };
10801
10802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextCtrl_SetStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10804     if (SWIG_arg_fail(1)) SWIG_fail;
10805     {
10806         arg2 = (long)(SWIG_As_long(obj1));
10807         if (SWIG_arg_fail(2)) SWIG_fail;
10808     }
10809     {
10810         arg3 = (long)(SWIG_As_long(obj2));
10811         if (SWIG_arg_fail(3)) SWIG_fail;
10812     }
10813     {
10814         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10815         if (SWIG_arg_fail(4)) SWIG_fail;
10816         if (arg4 == NULL) {
10817             SWIG_null_ref("wxTextAttr");
10818         }
10819         if (SWIG_arg_fail(4)) SWIG_fail;
10820     }
10821     {
10822         PyThreadState* __tstate = wxPyBeginAllowThreads();
10823         result = (bool)(arg1)->SetStyle(arg2,arg3,(wxTextAttr const &)*arg4);
10824
10825         wxPyEndAllowThreads(__tstate);
10826         if (PyErr_Occurred()) SWIG_fail;
10827     }
10828     {
10829         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10830     }
10831     return resultobj;
10832     fail:
10833     return NULL;
10834 }
10835
10836
10837 static PyObject *_wrap_TextCtrl_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10838     PyObject *resultobj;
10839     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10840     long arg2 ;
10841     wxTextAttr *arg3 = 0 ;
10842     bool result;
10843     PyObject * obj0 = 0 ;
10844     PyObject * obj1 = 0 ;
10845     PyObject * obj2 = 0 ;
10846     char *kwnames[] = {
10847         (char *) "self",(char *) "position",(char *) "style", NULL
10848     };
10849
10850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
10851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10852     if (SWIG_arg_fail(1)) SWIG_fail;
10853     {
10854         arg2 = (long)(SWIG_As_long(obj1));
10855         if (SWIG_arg_fail(2)) SWIG_fail;
10856     }
10857     {
10858         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10859         if (SWIG_arg_fail(3)) SWIG_fail;
10860         if (arg3 == NULL) {
10861             SWIG_null_ref("wxTextAttr");
10862         }
10863         if (SWIG_arg_fail(3)) SWIG_fail;
10864     }
10865     {
10866         PyThreadState* __tstate = wxPyBeginAllowThreads();
10867         result = (bool)(arg1)->GetStyle(arg2,*arg3);
10868
10869         wxPyEndAllowThreads(__tstate);
10870         if (PyErr_Occurred()) SWIG_fail;
10871     }
10872     {
10873         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10874     }
10875     return resultobj;
10876     fail:
10877     return NULL;
10878 }
10879
10880
10881 static PyObject *_wrap_TextCtrl_SetDefaultStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10882     PyObject *resultobj;
10883     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10884     wxTextAttr *arg2 = 0 ;
10885     bool result;
10886     PyObject * obj0 = 0 ;
10887     PyObject * obj1 = 0 ;
10888     char *kwnames[] = {
10889         (char *) "self",(char *) "style", NULL
10890     };
10891
10892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetDefaultStyle",kwnames,&obj0,&obj1)) goto fail;
10893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10894     if (SWIG_arg_fail(1)) SWIG_fail;
10895     {
10896         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10897         if (SWIG_arg_fail(2)) SWIG_fail;
10898         if (arg2 == NULL) {
10899             SWIG_null_ref("wxTextAttr");
10900         }
10901         if (SWIG_arg_fail(2)) SWIG_fail;
10902     }
10903     {
10904         PyThreadState* __tstate = wxPyBeginAllowThreads();
10905         result = (bool)(arg1)->SetDefaultStyle((wxTextAttr const &)*arg2);
10906
10907         wxPyEndAllowThreads(__tstate);
10908         if (PyErr_Occurred()) SWIG_fail;
10909     }
10910     {
10911         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10912     }
10913     return resultobj;
10914     fail:
10915     return NULL;
10916 }
10917
10918
10919 static PyObject *_wrap_TextCtrl_GetDefaultStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10920     PyObject *resultobj;
10921     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10922     wxTextAttr *result;
10923     PyObject * obj0 = 0 ;
10924     char *kwnames[] = {
10925         (char *) "self", NULL
10926     };
10927
10928     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetDefaultStyle",kwnames,&obj0)) goto fail;
10929     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10930     if (SWIG_arg_fail(1)) SWIG_fail;
10931     {
10932         PyThreadState* __tstate = wxPyBeginAllowThreads();
10933         {
10934             wxTextAttr const &_result_ref = ((wxTextCtrl const *)arg1)->GetDefaultStyle();
10935             result = (wxTextAttr *) &_result_ref;
10936         }
10937
10938         wxPyEndAllowThreads(__tstate);
10939         if (PyErr_Occurred()) SWIG_fail;
10940     }
10941     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextAttr, 0);
10942     return resultobj;
10943     fail:
10944     return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_TextCtrl_XYToPosition(PyObject *, PyObject *args, PyObject *kwargs) {
10949     PyObject *resultobj;
10950     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10951     long arg2 ;
10952     long arg3 ;
10953     long result;
10954     PyObject * obj0 = 0 ;
10955     PyObject * obj1 = 0 ;
10956     PyObject * obj2 = 0 ;
10957     char *kwnames[] = {
10958         (char *) "self",(char *) "x",(char *) "y", NULL
10959     };
10960
10961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_XYToPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
10962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10963     if (SWIG_arg_fail(1)) SWIG_fail;
10964     {
10965         arg2 = (long)(SWIG_As_long(obj1));
10966         if (SWIG_arg_fail(2)) SWIG_fail;
10967     }
10968     {
10969         arg3 = (long)(SWIG_As_long(obj2));
10970         if (SWIG_arg_fail(3)) SWIG_fail;
10971     }
10972     {
10973         PyThreadState* __tstate = wxPyBeginAllowThreads();
10974         result = (long)((wxTextCtrl const *)arg1)->XYToPosition(arg2,arg3);
10975
10976         wxPyEndAllowThreads(__tstate);
10977         if (PyErr_Occurred()) SWIG_fail;
10978     }
10979     {
10980         resultobj = SWIG_From_long((long)(result));
10981     }
10982     return resultobj;
10983     fail:
10984     return NULL;
10985 }
10986
10987
10988 static PyObject *_wrap_TextCtrl_PositionToXY(PyObject *, PyObject *args, PyObject *kwargs) {
10989     PyObject *resultobj;
10990     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10991     long arg2 ;
10992     long *arg3 = (long *) 0 ;
10993     long *arg4 = (long *) 0 ;
10994     long temp3 ;
10995     int res3 = 0 ;
10996     long temp4 ;
10997     int res4 = 0 ;
10998     PyObject * obj0 = 0 ;
10999     PyObject * obj1 = 0 ;
11000     char *kwnames[] = {
11001         (char *) "self",(char *) "pos", NULL
11002     };
11003
11004     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11005     arg4 = &temp4; res4 = SWIG_NEWOBJ;
11006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_PositionToXY",kwnames,&obj0,&obj1)) goto fail;
11007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11008     if (SWIG_arg_fail(1)) SWIG_fail;
11009     {
11010         arg2 = (long)(SWIG_As_long(obj1));
11011         if (SWIG_arg_fail(2)) SWIG_fail;
11012     }
11013     {
11014         PyThreadState* __tstate = wxPyBeginAllowThreads();
11015         ((wxTextCtrl const *)arg1)->PositionToXY(arg2,arg3,arg4);
11016
11017         wxPyEndAllowThreads(__tstate);
11018         if (PyErr_Occurred()) SWIG_fail;
11019     }
11020     Py_INCREF(Py_None); resultobj = Py_None;
11021     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11022     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11023     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11024     SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
11025     return resultobj;
11026     fail:
11027     return NULL;
11028 }
11029
11030
11031 static PyObject *_wrap_TextCtrl_ShowPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11032     PyObject *resultobj;
11033     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11034     long arg2 ;
11035     PyObject * obj0 = 0 ;
11036     PyObject * obj1 = 0 ;
11037     char *kwnames[] = {
11038         (char *) "self",(char *) "pos", NULL
11039     };
11040
11041     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_ShowPosition",kwnames,&obj0,&obj1)) goto fail;
11042     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11043     if (SWIG_arg_fail(1)) SWIG_fail;
11044     {
11045         arg2 = (long)(SWIG_As_long(obj1));
11046         if (SWIG_arg_fail(2)) SWIG_fail;
11047     }
11048     {
11049         PyThreadState* __tstate = wxPyBeginAllowThreads();
11050         (arg1)->ShowPosition(arg2);
11051
11052         wxPyEndAllowThreads(__tstate);
11053         if (PyErr_Occurred()) SWIG_fail;
11054     }
11055     Py_INCREF(Py_None); resultobj = Py_None;
11056     return resultobj;
11057     fail:
11058     return NULL;
11059 }
11060
11061
11062 static PyObject *_wrap_TextCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11063     PyObject *resultobj;
11064     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11065     wxPoint *arg2 = 0 ;
11066     long *arg3 = (long *) 0 ;
11067     long *arg4 = (long *) 0 ;
11068     wxTextCtrlHitTestResult result;
11069     wxPoint temp2 ;
11070     long temp3 ;
11071     int res3 = 0 ;
11072     long temp4 ;
11073     int res4 = 0 ;
11074     PyObject * obj0 = 0 ;
11075     PyObject * obj1 = 0 ;
11076     char *kwnames[] = {
11077         (char *) "self",(char *) "pt", NULL
11078     };
11079
11080     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11081     arg4 = &temp4; res4 = SWIG_NEWOBJ;
11082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
11083     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11084     if (SWIG_arg_fail(1)) SWIG_fail;
11085     {
11086         arg2 = &temp2;
11087         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11088     }
11089     {
11090         PyThreadState* __tstate = wxPyBeginAllowThreads();
11091         result = (wxTextCtrlHitTestResult)((wxTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3,arg4);
11092
11093         wxPyEndAllowThreads(__tstate);
11094         if (PyErr_Occurred()) SWIG_fail;
11095     }
11096     resultobj = SWIG_From_int((result));
11097     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11098     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11099     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11100     SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
11101     return resultobj;
11102     fail:
11103     return NULL;
11104 }
11105
11106
11107 static PyObject *_wrap_TextCtrl_HitTestPos(PyObject *, PyObject *args, PyObject *kwargs) {
11108     PyObject *resultobj;
11109     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11110     wxPoint *arg2 = 0 ;
11111     long *arg3 = (long *) 0 ;
11112     wxTextCtrlHitTestResult result;
11113     wxPoint temp2 ;
11114     long temp3 ;
11115     int res3 = 0 ;
11116     PyObject * obj0 = 0 ;
11117     PyObject * obj1 = 0 ;
11118     char *kwnames[] = {
11119         (char *) "self",(char *) "pt", NULL
11120     };
11121
11122     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_HitTestPos",kwnames,&obj0,&obj1)) goto fail;
11124     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11125     if (SWIG_arg_fail(1)) SWIG_fail;
11126     {
11127         arg2 = &temp2;
11128         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11129     }
11130     {
11131         PyThreadState* __tstate = wxPyBeginAllowThreads();
11132         result = (wxTextCtrlHitTestResult)((wxTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3);
11133
11134         wxPyEndAllowThreads(__tstate);
11135         if (PyErr_Occurred()) SWIG_fail;
11136     }
11137     resultobj = SWIG_From_int((result));
11138     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11139     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11140     return resultobj;
11141     fail:
11142     return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_TextCtrl_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
11147     PyObject *resultobj;
11148     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11149     PyObject * obj0 = 0 ;
11150     char *kwnames[] = {
11151         (char *) "self", NULL
11152     };
11153
11154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Copy",kwnames,&obj0)) goto fail;
11155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11156     if (SWIG_arg_fail(1)) SWIG_fail;
11157     {
11158         PyThreadState* __tstate = wxPyBeginAllowThreads();
11159         (arg1)->Copy();
11160
11161         wxPyEndAllowThreads(__tstate);
11162         if (PyErr_Occurred()) SWIG_fail;
11163     }
11164     Py_INCREF(Py_None); resultobj = Py_None;
11165     return resultobj;
11166     fail:
11167     return NULL;
11168 }
11169
11170
11171 static PyObject *_wrap_TextCtrl_Cut(PyObject *, PyObject *args, PyObject *kwargs) {
11172     PyObject *resultobj;
11173     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11174     PyObject * obj0 = 0 ;
11175     char *kwnames[] = {
11176         (char *) "self", NULL
11177     };
11178
11179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Cut",kwnames,&obj0)) goto fail;
11180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11181     if (SWIG_arg_fail(1)) SWIG_fail;
11182     {
11183         PyThreadState* __tstate = wxPyBeginAllowThreads();
11184         (arg1)->Cut();
11185
11186         wxPyEndAllowThreads(__tstate);
11187         if (PyErr_Occurred()) SWIG_fail;
11188     }
11189     Py_INCREF(Py_None); resultobj = Py_None;
11190     return resultobj;
11191     fail:
11192     return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_TextCtrl_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
11197     PyObject *resultobj;
11198     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11199     PyObject * obj0 = 0 ;
11200     char *kwnames[] = {
11201         (char *) "self", NULL
11202     };
11203
11204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Paste",kwnames,&obj0)) goto fail;
11205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11206     if (SWIG_arg_fail(1)) SWIG_fail;
11207     {
11208         PyThreadState* __tstate = wxPyBeginAllowThreads();
11209         (arg1)->Paste();
11210
11211         wxPyEndAllowThreads(__tstate);
11212         if (PyErr_Occurred()) SWIG_fail;
11213     }
11214     Py_INCREF(Py_None); resultobj = Py_None;
11215     return resultobj;
11216     fail:
11217     return NULL;
11218 }
11219
11220
11221 static PyObject *_wrap_TextCtrl_CanCopy(PyObject *, PyObject *args, PyObject *kwargs) {
11222     PyObject *resultobj;
11223     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11224     bool result;
11225     PyObject * obj0 = 0 ;
11226     char *kwnames[] = {
11227         (char *) "self", NULL
11228     };
11229
11230     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanCopy",kwnames,&obj0)) goto fail;
11231     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11232     if (SWIG_arg_fail(1)) SWIG_fail;
11233     {
11234         PyThreadState* __tstate = wxPyBeginAllowThreads();
11235         result = (bool)((wxTextCtrl const *)arg1)->CanCopy();
11236
11237         wxPyEndAllowThreads(__tstate);
11238         if (PyErr_Occurred()) SWIG_fail;
11239     }
11240     {
11241         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11242     }
11243     return resultobj;
11244     fail:
11245     return NULL;
11246 }
11247
11248
11249 static PyObject *_wrap_TextCtrl_CanCut(PyObject *, PyObject *args, PyObject *kwargs) {
11250     PyObject *resultobj;
11251     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11252     bool result;
11253     PyObject * obj0 = 0 ;
11254     char *kwnames[] = {
11255         (char *) "self", NULL
11256     };
11257
11258     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanCut",kwnames,&obj0)) goto fail;
11259     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11260     if (SWIG_arg_fail(1)) SWIG_fail;
11261     {
11262         PyThreadState* __tstate = wxPyBeginAllowThreads();
11263         result = (bool)((wxTextCtrl const *)arg1)->CanCut();
11264
11265         wxPyEndAllowThreads(__tstate);
11266         if (PyErr_Occurred()) SWIG_fail;
11267     }
11268     {
11269         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11270     }
11271     return resultobj;
11272     fail:
11273     return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_TextCtrl_CanPaste(PyObject *, PyObject *args, PyObject *kwargs) {
11278     PyObject *resultobj;
11279     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11280     bool result;
11281     PyObject * obj0 = 0 ;
11282     char *kwnames[] = {
11283         (char *) "self", NULL
11284     };
11285
11286     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanPaste",kwnames,&obj0)) goto fail;
11287     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11288     if (SWIG_arg_fail(1)) SWIG_fail;
11289     {
11290         PyThreadState* __tstate = wxPyBeginAllowThreads();
11291         result = (bool)((wxTextCtrl const *)arg1)->CanPaste();
11292
11293         wxPyEndAllowThreads(__tstate);
11294         if (PyErr_Occurred()) SWIG_fail;
11295     }
11296     {
11297         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11298     }
11299     return resultobj;
11300     fail:
11301     return NULL;
11302 }
11303
11304
11305 static PyObject *_wrap_TextCtrl_Undo(PyObject *, PyObject *args, PyObject *kwargs) {
11306     PyObject *resultobj;
11307     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11308     PyObject * obj0 = 0 ;
11309     char *kwnames[] = {
11310         (char *) "self", NULL
11311     };
11312
11313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Undo",kwnames,&obj0)) goto fail;
11314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11315     if (SWIG_arg_fail(1)) SWIG_fail;
11316     {
11317         PyThreadState* __tstate = wxPyBeginAllowThreads();
11318         (arg1)->Undo();
11319
11320         wxPyEndAllowThreads(__tstate);
11321         if (PyErr_Occurred()) SWIG_fail;
11322     }
11323     Py_INCREF(Py_None); resultobj = Py_None;
11324     return resultobj;
11325     fail:
11326     return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_TextCtrl_Redo(PyObject *, PyObject *args, PyObject *kwargs) {
11331     PyObject *resultobj;
11332     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11333     PyObject * obj0 = 0 ;
11334     char *kwnames[] = {
11335         (char *) "self", NULL
11336     };
11337
11338     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Redo",kwnames,&obj0)) goto fail;
11339     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11340     if (SWIG_arg_fail(1)) SWIG_fail;
11341     {
11342         PyThreadState* __tstate = wxPyBeginAllowThreads();
11343         (arg1)->Redo();
11344
11345         wxPyEndAllowThreads(__tstate);
11346         if (PyErr_Occurred()) SWIG_fail;
11347     }
11348     Py_INCREF(Py_None); resultobj = Py_None;
11349     return resultobj;
11350     fail:
11351     return NULL;
11352 }
11353
11354
11355 static PyObject *_wrap_TextCtrl_CanUndo(PyObject *, PyObject *args, PyObject *kwargs) {
11356     PyObject *resultobj;
11357     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11358     bool result;
11359     PyObject * obj0 = 0 ;
11360     char *kwnames[] = {
11361         (char *) "self", NULL
11362     };
11363
11364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanUndo",kwnames,&obj0)) goto fail;
11365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11366     if (SWIG_arg_fail(1)) SWIG_fail;
11367     {
11368         PyThreadState* __tstate = wxPyBeginAllowThreads();
11369         result = (bool)((wxTextCtrl const *)arg1)->CanUndo();
11370
11371         wxPyEndAllowThreads(__tstate);
11372         if (PyErr_Occurred()) SWIG_fail;
11373     }
11374     {
11375         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11376     }
11377     return resultobj;
11378     fail:
11379     return NULL;
11380 }
11381
11382
11383 static PyObject *_wrap_TextCtrl_CanRedo(PyObject *, PyObject *args, PyObject *kwargs) {
11384     PyObject *resultobj;
11385     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11386     bool result;
11387     PyObject * obj0 = 0 ;
11388     char *kwnames[] = {
11389         (char *) "self", NULL
11390     };
11391
11392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanRedo",kwnames,&obj0)) goto fail;
11393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11394     if (SWIG_arg_fail(1)) SWIG_fail;
11395     {
11396         PyThreadState* __tstate = wxPyBeginAllowThreads();
11397         result = (bool)((wxTextCtrl const *)arg1)->CanRedo();
11398
11399         wxPyEndAllowThreads(__tstate);
11400         if (PyErr_Occurred()) SWIG_fail;
11401     }
11402     {
11403         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404     }
11405     return resultobj;
11406     fail:
11407     return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_TextCtrl_SetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
11412     PyObject *resultobj;
11413     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11414     long arg2 ;
11415     PyObject * obj0 = 0 ;
11416     PyObject * obj1 = 0 ;
11417     char *kwnames[] = {
11418         (char *) "self",(char *) "pos", NULL
11419     };
11420
11421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetInsertionPoint",kwnames,&obj0,&obj1)) goto fail;
11422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11423     if (SWIG_arg_fail(1)) SWIG_fail;
11424     {
11425         arg2 = (long)(SWIG_As_long(obj1));
11426         if (SWIG_arg_fail(2)) SWIG_fail;
11427     }
11428     {
11429         PyThreadState* __tstate = wxPyBeginAllowThreads();
11430         (arg1)->SetInsertionPoint(arg2);
11431
11432         wxPyEndAllowThreads(__tstate);
11433         if (PyErr_Occurred()) SWIG_fail;
11434     }
11435     Py_INCREF(Py_None); resultobj = Py_None;
11436     return resultobj;
11437     fail:
11438     return NULL;
11439 }
11440
11441
11442 static PyObject *_wrap_TextCtrl_SetInsertionPointEnd(PyObject *, PyObject *args, PyObject *kwargs) {
11443     PyObject *resultobj;
11444     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11445     PyObject * obj0 = 0 ;
11446     char *kwnames[] = {
11447         (char *) "self", NULL
11448     };
11449
11450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_SetInsertionPointEnd",kwnames,&obj0)) goto fail;
11451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11452     if (SWIG_arg_fail(1)) SWIG_fail;
11453     {
11454         PyThreadState* __tstate = wxPyBeginAllowThreads();
11455         (arg1)->SetInsertionPointEnd();
11456
11457         wxPyEndAllowThreads(__tstate);
11458         if (PyErr_Occurred()) SWIG_fail;
11459     }
11460     Py_INCREF(Py_None); resultobj = Py_None;
11461     return resultobj;
11462     fail:
11463     return NULL;
11464 }
11465
11466
11467 static PyObject *_wrap_TextCtrl_GetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
11468     PyObject *resultobj;
11469     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11470     long result;
11471     PyObject * obj0 = 0 ;
11472     char *kwnames[] = {
11473         (char *) "self", NULL
11474     };
11475
11476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetInsertionPoint",kwnames,&obj0)) goto fail;
11477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11478     if (SWIG_arg_fail(1)) SWIG_fail;
11479     {
11480         PyThreadState* __tstate = wxPyBeginAllowThreads();
11481         result = (long)((wxTextCtrl const *)arg1)->GetInsertionPoint();
11482
11483         wxPyEndAllowThreads(__tstate);
11484         if (PyErr_Occurred()) SWIG_fail;
11485     }
11486     {
11487         resultobj = SWIG_From_long((long)(result));
11488     }
11489     return resultobj;
11490     fail:
11491     return NULL;
11492 }
11493
11494
11495 static PyObject *_wrap_TextCtrl_GetLastPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11496     PyObject *resultobj;
11497     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11498     long result;
11499     PyObject * obj0 = 0 ;
11500     char *kwnames[] = {
11501         (char *) "self", NULL
11502     };
11503
11504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetLastPosition",kwnames,&obj0)) goto fail;
11505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11506     if (SWIG_arg_fail(1)) SWIG_fail;
11507     {
11508         PyThreadState* __tstate = wxPyBeginAllowThreads();
11509         result = (long)((wxTextCtrl const *)arg1)->GetLastPosition();
11510
11511         wxPyEndAllowThreads(__tstate);
11512         if (PyErr_Occurred()) SWIG_fail;
11513     }
11514     {
11515         resultobj = SWIG_From_long((long)(result));
11516     }
11517     return resultobj;
11518     fail:
11519     return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_TextCtrl_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11524     PyObject *resultobj;
11525     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11526     long arg2 ;
11527     long arg3 ;
11528     PyObject * obj0 = 0 ;
11529     PyObject * obj1 = 0 ;
11530     PyObject * obj2 = 0 ;
11531     char *kwnames[] = {
11532         (char *) "self",(char *) "from",(char *) "to", NULL
11533     };
11534
11535     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
11536     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11537     if (SWIG_arg_fail(1)) SWIG_fail;
11538     {
11539         arg2 = (long)(SWIG_As_long(obj1));
11540         if (SWIG_arg_fail(2)) SWIG_fail;
11541     }
11542     {
11543         arg3 = (long)(SWIG_As_long(obj2));
11544         if (SWIG_arg_fail(3)) SWIG_fail;
11545     }
11546     {
11547         PyThreadState* __tstate = wxPyBeginAllowThreads();
11548         (arg1)->SetSelection(arg2,arg3);
11549
11550         wxPyEndAllowThreads(__tstate);
11551         if (PyErr_Occurred()) SWIG_fail;
11552     }
11553     Py_INCREF(Py_None); resultobj = Py_None;
11554     return resultobj;
11555     fail:
11556     return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_TextCtrl_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
11561     PyObject *resultobj;
11562     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11563     PyObject * obj0 = 0 ;
11564     char *kwnames[] = {
11565         (char *) "self", NULL
11566     };
11567
11568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_SelectAll",kwnames,&obj0)) goto fail;
11569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11570     if (SWIG_arg_fail(1)) SWIG_fail;
11571     {
11572         PyThreadState* __tstate = wxPyBeginAllowThreads();
11573         (arg1)->SelectAll();
11574
11575         wxPyEndAllowThreads(__tstate);
11576         if (PyErr_Occurred()) SWIG_fail;
11577     }
11578     Py_INCREF(Py_None); resultobj = Py_None;
11579     return resultobj;
11580     fail:
11581     return NULL;
11582 }
11583
11584
11585 static PyObject *_wrap_TextCtrl_SetEditable(PyObject *, PyObject *args, PyObject *kwargs) {
11586     PyObject *resultobj;
11587     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11588     bool arg2 ;
11589     PyObject * obj0 = 0 ;
11590     PyObject * obj1 = 0 ;
11591     char *kwnames[] = {
11592         (char *) "self",(char *) "editable", NULL
11593     };
11594
11595     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetEditable",kwnames,&obj0,&obj1)) goto fail;
11596     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11597     if (SWIG_arg_fail(1)) SWIG_fail;
11598     {
11599         arg2 = (bool)(SWIG_As_bool(obj1));
11600         if (SWIG_arg_fail(2)) SWIG_fail;
11601     }
11602     {
11603         PyThreadState* __tstate = wxPyBeginAllowThreads();
11604         (arg1)->SetEditable(arg2);
11605
11606         wxPyEndAllowThreads(__tstate);
11607         if (PyErr_Occurred()) SWIG_fail;
11608     }
11609     Py_INCREF(Py_None); resultobj = Py_None;
11610     return resultobj;
11611     fail:
11612     return NULL;
11613 }
11614
11615
11616 static PyObject *_wrap_TextCtrl_ShowNativeCaret(PyObject *, PyObject *args, PyObject *kwargs) {
11617     PyObject *resultobj;
11618     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11619     bool arg2 = (bool) true ;
11620     bool result;
11621     PyObject * obj0 = 0 ;
11622     PyObject * obj1 = 0 ;
11623     char *kwnames[] = {
11624         (char *) "self",(char *) "show", NULL
11625     };
11626
11627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TextCtrl_ShowNativeCaret",kwnames,&obj0,&obj1)) goto fail;
11628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11629     if (SWIG_arg_fail(1)) SWIG_fail;
11630     if (obj1) {
11631         {
11632             arg2 = (bool)(SWIG_As_bool(obj1));
11633             if (SWIG_arg_fail(2)) SWIG_fail;
11634         }
11635     }
11636     {
11637         PyThreadState* __tstate = wxPyBeginAllowThreads();
11638         result = (bool)(arg1)->ShowNativeCaret(arg2);
11639
11640         wxPyEndAllowThreads(__tstate);
11641         if (PyErr_Occurred()) SWIG_fail;
11642     }
11643     {
11644         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11645     }
11646     return resultobj;
11647     fail:
11648     return NULL;
11649 }
11650
11651
11652 static PyObject *_wrap_TextCtrl_HideNativeCaret(PyObject *, PyObject *args, PyObject *kwargs) {
11653     PyObject *resultobj;
11654     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11655     bool result;
11656     PyObject * obj0 = 0 ;
11657     char *kwnames[] = {
11658         (char *) "self", NULL
11659     };
11660
11661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_HideNativeCaret",kwnames,&obj0)) goto fail;
11662     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11663     if (SWIG_arg_fail(1)) SWIG_fail;
11664     {
11665         PyThreadState* __tstate = wxPyBeginAllowThreads();
11666         result = (bool)(arg1)->HideNativeCaret();
11667
11668         wxPyEndAllowThreads(__tstate);
11669         if (PyErr_Occurred()) SWIG_fail;
11670     }
11671     {
11672         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11673     }
11674     return resultobj;
11675     fail:
11676     return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_TextCtrl_write(PyObject *, PyObject *args, PyObject *kwargs) {
11681     PyObject *resultobj;
11682     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11683     wxString *arg2 = 0 ;
11684     bool temp2 = false ;
11685     PyObject * obj0 = 0 ;
11686     PyObject * obj1 = 0 ;
11687     char *kwnames[] = {
11688         (char *) "self",(char *) "text", NULL
11689     };
11690
11691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_write",kwnames,&obj0,&obj1)) goto fail;
11692     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11693     if (SWIG_arg_fail(1)) SWIG_fail;
11694     {
11695         arg2 = wxString_in_helper(obj1);
11696         if (arg2 == NULL) SWIG_fail;
11697         temp2 = true;
11698     }
11699     {
11700         PyThreadState* __tstate = wxPyBeginAllowThreads();
11701         wxTextCtrl_write(arg1,(wxString const &)*arg2);
11702
11703         wxPyEndAllowThreads(__tstate);
11704         if (PyErr_Occurred()) SWIG_fail;
11705     }
11706     Py_INCREF(Py_None); resultobj = Py_None;
11707     {
11708         if (temp2)
11709         delete arg2;
11710     }
11711     return resultobj;
11712     fail:
11713     {
11714         if (temp2)
11715         delete arg2;
11716     }
11717     return NULL;
11718 }
11719
11720
11721 static PyObject *_wrap_TextCtrl_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11722     PyObject *resultobj;
11723     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11724     long arg2 ;
11725     long arg3 ;
11726     wxString result;
11727     PyObject * obj0 = 0 ;
11728     PyObject * obj1 = 0 ;
11729     PyObject * obj2 = 0 ;
11730     char *kwnames[] = {
11731         (char *) "self",(char *) "from",(char *) "to", NULL
11732     };
11733
11734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11736     if (SWIG_arg_fail(1)) SWIG_fail;
11737     {
11738         arg2 = (long)(SWIG_As_long(obj1));
11739         if (SWIG_arg_fail(2)) SWIG_fail;
11740     }
11741     {
11742         arg3 = (long)(SWIG_As_long(obj2));
11743         if (SWIG_arg_fail(3)) SWIG_fail;
11744     }
11745     {
11746         PyThreadState* __tstate = wxPyBeginAllowThreads();
11747         result = wxTextCtrl_GetString(arg1,arg2,arg3);
11748
11749         wxPyEndAllowThreads(__tstate);
11750         if (PyErr_Occurred()) SWIG_fail;
11751     }
11752     {
11753 #if wxUSE_UNICODE
11754         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11755 #else
11756         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11757 #endif
11758     }
11759     return resultobj;
11760     fail:
11761     return NULL;
11762 }
11763
11764
11765 static PyObject *_wrap_TextCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
11766     PyObject *resultobj;
11767     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
11768     wxVisualAttributes result;
11769     PyObject * obj0 = 0 ;
11770     char *kwnames[] = {
11771         (char *) "variant", NULL
11772     };
11773
11774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TextCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
11775     if (obj0) {
11776         {
11777             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
11778             if (SWIG_arg_fail(1)) SWIG_fail;
11779         }
11780     }
11781     {
11782         if (!wxPyCheckForApp()) SWIG_fail;
11783         PyThreadState* __tstate = wxPyBeginAllowThreads();
11784         result = wxTextCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
11785
11786         wxPyEndAllowThreads(__tstate);
11787         if (PyErr_Occurred()) SWIG_fail;
11788     }
11789     {
11790         wxVisualAttributes * resultptr;
11791         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
11792         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
11793     }
11794     return resultobj;
11795     fail:
11796     return NULL;
11797 }
11798
11799
11800 static PyObject * TextCtrl_swigregister(PyObject *, PyObject *args) {
11801     PyObject *obj;
11802     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11803     SWIG_TypeClientData(SWIGTYPE_p_wxTextCtrl, obj);
11804     Py_INCREF(obj);
11805     return Py_BuildValue((char *)"");
11806 }
11807 static PyObject *_wrap_new_TextUrlEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11808     PyObject *resultobj;
11809     int arg1 ;
11810     wxMouseEvent *arg2 = 0 ;
11811     long arg3 ;
11812     long arg4 ;
11813     wxTextUrlEvent *result;
11814     PyObject * obj0 = 0 ;
11815     PyObject * obj1 = 0 ;
11816     PyObject * obj2 = 0 ;
11817     PyObject * obj3 = 0 ;
11818     char *kwnames[] = {
11819         (char *) "winid",(char *) "evtMouse",(char *) "start",(char *) "end", NULL
11820     };
11821
11822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_TextUrlEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11823     {
11824         arg1 = (int)(SWIG_As_int(obj0));
11825         if (SWIG_arg_fail(1)) SWIG_fail;
11826     }
11827     {
11828         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
11829         if (SWIG_arg_fail(2)) SWIG_fail;
11830         if (arg2 == NULL) {
11831             SWIG_null_ref("wxMouseEvent");
11832         }
11833         if (SWIG_arg_fail(2)) SWIG_fail;
11834     }
11835     {
11836         arg3 = (long)(SWIG_As_long(obj2));
11837         if (SWIG_arg_fail(3)) SWIG_fail;
11838     }
11839     {
11840         arg4 = (long)(SWIG_As_long(obj3));
11841         if (SWIG_arg_fail(4)) SWIG_fail;
11842     }
11843     {
11844         PyThreadState* __tstate = wxPyBeginAllowThreads();
11845         result = (wxTextUrlEvent *)new wxTextUrlEvent(arg1,(wxMouseEvent const &)*arg2,arg3,arg4);
11846
11847         wxPyEndAllowThreads(__tstate);
11848         if (PyErr_Occurred()) SWIG_fail;
11849     }
11850     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextUrlEvent, 1);
11851     return resultobj;
11852     fail:
11853     return NULL;
11854 }
11855
11856
11857 static PyObject *_wrap_TextUrlEvent_GetMouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11858     PyObject *resultobj;
11859     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11860     wxMouseEvent *result;
11861     PyObject * obj0 = 0 ;
11862     char *kwnames[] = {
11863         (char *) "self", NULL
11864     };
11865
11866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetMouseEvent",kwnames,&obj0)) goto fail;
11867     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11868     if (SWIG_arg_fail(1)) SWIG_fail;
11869     {
11870         PyThreadState* __tstate = wxPyBeginAllowThreads();
11871         {
11872             wxMouseEvent const &_result_ref = (arg1)->GetMouseEvent();
11873             result = (wxMouseEvent *) &_result_ref;
11874         }
11875
11876         wxPyEndAllowThreads(__tstate);
11877         if (PyErr_Occurred()) SWIG_fail;
11878     }
11879     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseEvent, 0);
11880     return resultobj;
11881     fail:
11882     return NULL;
11883 }
11884
11885
11886 static PyObject *_wrap_TextUrlEvent_GetURLStart(PyObject *, PyObject *args, PyObject *kwargs) {
11887     PyObject *resultobj;
11888     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11889     long result;
11890     PyObject * obj0 = 0 ;
11891     char *kwnames[] = {
11892         (char *) "self", NULL
11893     };
11894
11895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetURLStart",kwnames,&obj0)) goto fail;
11896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11897     if (SWIG_arg_fail(1)) SWIG_fail;
11898     {
11899         PyThreadState* __tstate = wxPyBeginAllowThreads();
11900         result = (long)((wxTextUrlEvent const *)arg1)->GetURLStart();
11901
11902         wxPyEndAllowThreads(__tstate);
11903         if (PyErr_Occurred()) SWIG_fail;
11904     }
11905     {
11906         resultobj = SWIG_From_long((long)(result));
11907     }
11908     return resultobj;
11909     fail:
11910     return NULL;
11911 }
11912
11913
11914 static PyObject *_wrap_TextUrlEvent_GetURLEnd(PyObject *, PyObject *args, PyObject *kwargs) {
11915     PyObject *resultobj;
11916     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11917     long result;
11918     PyObject * obj0 = 0 ;
11919     char *kwnames[] = {
11920         (char *) "self", NULL
11921     };
11922
11923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetURLEnd",kwnames,&obj0)) goto fail;
11924     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11925     if (SWIG_arg_fail(1)) SWIG_fail;
11926     {
11927         PyThreadState* __tstate = wxPyBeginAllowThreads();
11928         result = (long)((wxTextUrlEvent const *)arg1)->GetURLEnd();
11929
11930         wxPyEndAllowThreads(__tstate);
11931         if (PyErr_Occurred()) SWIG_fail;
11932     }
11933     {
11934         resultobj = SWIG_From_long((long)(result));
11935     }
11936     return resultobj;
11937     fail:
11938     return NULL;
11939 }
11940
11941
11942 static PyObject * TextUrlEvent_swigregister(PyObject *, PyObject *args) {
11943     PyObject *obj;
11944     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11945     SWIG_TypeClientData(SWIGTYPE_p_wxTextUrlEvent, obj);
11946     Py_INCREF(obj);
11947     return Py_BuildValue((char *)"");
11948 }
11949 static int _wrap_ScrollBarNameStr_set(PyObject *) {
11950     PyErr_SetString(PyExc_TypeError,"Variable ScrollBarNameStr is read-only.");
11951     return 1;
11952 }
11953
11954
11955 static PyObject *_wrap_ScrollBarNameStr_get(void) {
11956     PyObject *pyobj;
11957
11958     {
11959 #if wxUSE_UNICODE
11960         pyobj = PyUnicode_FromWideChar((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
11961 #else
11962         pyobj = PyString_FromStringAndSize((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
11963 #endif
11964     }
11965     return pyobj;
11966 }
11967
11968
11969 static PyObject *_wrap_new_ScrollBar(PyObject *, PyObject *args, PyObject *kwargs) {
11970     PyObject *resultobj;
11971     wxWindow *arg1 = (wxWindow *) 0 ;
11972     int arg2 = (int) -1 ;
11973     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11974     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11975     wxSize const &arg4_defvalue = wxDefaultSize ;
11976     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11977     long arg5 = (long) wxSB_HORIZONTAL ;
11978     wxValidator const &arg6_defvalue = wxDefaultValidator ;
11979     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
11980     wxString const &arg7_defvalue = wxPyScrollBarNameStr ;
11981     wxString *arg7 = (wxString *) &arg7_defvalue ;
11982     wxScrollBar *result;
11983     wxPoint temp3 ;
11984     wxSize temp4 ;
11985     bool temp7 = false ;
11986     PyObject * obj0 = 0 ;
11987     PyObject * obj1 = 0 ;
11988     PyObject * obj2 = 0 ;
11989     PyObject * obj3 = 0 ;
11990     PyObject * obj4 = 0 ;
11991     PyObject * obj5 = 0 ;
11992     PyObject * obj6 = 0 ;
11993     char *kwnames[] = {
11994         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
11995     };
11996
11997     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ScrollBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11998     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11999     if (SWIG_arg_fail(1)) SWIG_fail;
12000     if (obj1) {
12001         {
12002             arg2 = (int)(SWIG_As_int(obj1));
12003             if (SWIG_arg_fail(2)) SWIG_fail;
12004         }
12005     }
12006     if (obj2) {
12007         {
12008             arg3 = &temp3;
12009             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12010         }
12011     }
12012     if (obj3) {
12013         {
12014             arg4 = &temp4;
12015             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12016         }
12017     }
12018     if (obj4) {
12019         {
12020             arg5 = (long)(SWIG_As_long(obj4));
12021             if (SWIG_arg_fail(5)) SWIG_fail;
12022         }
12023     }
12024     if (obj5) {
12025         {
12026             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
12027             if (SWIG_arg_fail(6)) SWIG_fail;
12028             if (arg6 == NULL) {
12029                 SWIG_null_ref("wxValidator");
12030             }
12031             if (SWIG_arg_fail(6)) SWIG_fail;
12032         }
12033     }
12034     if (obj6) {
12035         {
12036             arg7 = wxString_in_helper(obj6);
12037             if (arg7 == NULL) SWIG_fail;
12038             temp7 = true;
12039         }
12040     }
12041     {
12042         if (!wxPyCheckForApp()) SWIG_fail;
12043         PyThreadState* __tstate = wxPyBeginAllowThreads();
12044         result = (wxScrollBar *)new wxScrollBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
12045
12046         wxPyEndAllowThreads(__tstate);
12047         if (PyErr_Occurred()) SWIG_fail;
12048     }
12049     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollBar, 1);
12050     {
12051         if (temp7)
12052         delete arg7;
12053     }
12054     return resultobj;
12055     fail:
12056     {
12057         if (temp7)
12058         delete arg7;
12059     }
12060     return NULL;
12061 }
12062
12063
12064 static PyObject *_wrap_new_PreScrollBar(PyObject *, PyObject *args, PyObject *kwargs) {
12065     PyObject *resultobj;
12066     wxScrollBar *result;
12067     char *kwnames[] = {
12068         NULL
12069     };
12070
12071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreScrollBar",kwnames)) goto fail;
12072     {
12073         if (!wxPyCheckForApp()) SWIG_fail;
12074         PyThreadState* __tstate = wxPyBeginAllowThreads();
12075         result = (wxScrollBar *)new wxScrollBar();
12076
12077         wxPyEndAllowThreads(__tstate);
12078         if (PyErr_Occurred()) SWIG_fail;
12079     }
12080     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollBar, 1);
12081     return resultobj;
12082     fail:
12083     return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_ScrollBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12088     PyObject *resultobj;
12089     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12090     wxWindow *arg2 = (wxWindow *) 0 ;
12091     int arg3 = (int) -1 ;
12092     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12093     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12094     wxSize const &arg5_defvalue = wxDefaultSize ;
12095     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12096     long arg6 = (long) wxSB_HORIZONTAL ;
12097     wxValidator const &arg7_defvalue = wxDefaultValidator ;
12098     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
12099     wxString const &arg8_defvalue = wxPyScrollBarNameStr ;
12100     wxString *arg8 = (wxString *) &arg8_defvalue ;
12101     bool result;
12102     wxPoint temp4 ;
12103     wxSize temp5 ;
12104     bool temp8 = false ;
12105     PyObject * obj0 = 0 ;
12106     PyObject * obj1 = 0 ;
12107     PyObject * obj2 = 0 ;
12108     PyObject * obj3 = 0 ;
12109     PyObject * obj4 = 0 ;
12110     PyObject * obj5 = 0 ;
12111     PyObject * obj6 = 0 ;
12112     PyObject * obj7 = 0 ;
12113     char *kwnames[] = {
12114         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
12115     };
12116
12117     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ScrollBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
12118     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12119     if (SWIG_arg_fail(1)) SWIG_fail;
12120     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12121     if (SWIG_arg_fail(2)) SWIG_fail;
12122     if (obj2) {
12123         {
12124             arg3 = (int)(SWIG_As_int(obj2));
12125             if (SWIG_arg_fail(3)) SWIG_fail;
12126         }
12127     }
12128     if (obj3) {
12129         {
12130             arg4 = &temp4;
12131             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12132         }
12133     }
12134     if (obj4) {
12135         {
12136             arg5 = &temp5;
12137             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12138         }
12139     }
12140     if (obj5) {
12141         {
12142             arg6 = (long)(SWIG_As_long(obj5));
12143             if (SWIG_arg_fail(6)) SWIG_fail;
12144         }
12145     }
12146     if (obj6) {
12147         {
12148             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
12149             if (SWIG_arg_fail(7)) SWIG_fail;
12150             if (arg7 == NULL) {
12151                 SWIG_null_ref("wxValidator");
12152             }
12153             if (SWIG_arg_fail(7)) SWIG_fail;
12154         }
12155     }
12156     if (obj7) {
12157         {
12158             arg8 = wxString_in_helper(obj7);
12159             if (arg8 == NULL) SWIG_fail;
12160             temp8 = true;
12161         }
12162     }
12163     {
12164         PyThreadState* __tstate = wxPyBeginAllowThreads();
12165         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
12166
12167         wxPyEndAllowThreads(__tstate);
12168         if (PyErr_Occurred()) SWIG_fail;
12169     }
12170     {
12171         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12172     }
12173     {
12174         if (temp8)
12175         delete arg8;
12176     }
12177     return resultobj;
12178     fail:
12179     {
12180         if (temp8)
12181         delete arg8;
12182     }
12183     return NULL;
12184 }
12185
12186
12187 static PyObject *_wrap_ScrollBar_GetThumbPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12188     PyObject *resultobj;
12189     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12190     int result;
12191     PyObject * obj0 = 0 ;
12192     char *kwnames[] = {
12193         (char *) "self", NULL
12194     };
12195
12196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetThumbPosition",kwnames,&obj0)) goto fail;
12197     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12198     if (SWIG_arg_fail(1)) SWIG_fail;
12199     {
12200         PyThreadState* __tstate = wxPyBeginAllowThreads();
12201         result = (int)((wxScrollBar const *)arg1)->GetThumbPosition();
12202
12203         wxPyEndAllowThreads(__tstate);
12204         if (PyErr_Occurred()) SWIG_fail;
12205     }
12206     {
12207         resultobj = SWIG_From_int((int)(result));
12208     }
12209     return resultobj;
12210     fail:
12211     return NULL;
12212 }
12213
12214
12215 static PyObject *_wrap_ScrollBar_GetThumbSize(PyObject *, PyObject *args, PyObject *kwargs) {
12216     PyObject *resultobj;
12217     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12218     int result;
12219     PyObject * obj0 = 0 ;
12220     char *kwnames[] = {
12221         (char *) "self", NULL
12222     };
12223
12224     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetThumbSize",kwnames,&obj0)) goto fail;
12225     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12226     if (SWIG_arg_fail(1)) SWIG_fail;
12227     {
12228         PyThreadState* __tstate = wxPyBeginAllowThreads();
12229         result = (int)((wxScrollBar const *)arg1)->GetThumbSize();
12230
12231         wxPyEndAllowThreads(__tstate);
12232         if (PyErr_Occurred()) SWIG_fail;
12233     }
12234     {
12235         resultobj = SWIG_From_int((int)(result));
12236     }
12237     return resultobj;
12238     fail:
12239     return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_ScrollBar_GetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
12244     PyObject *resultobj;
12245     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12246     int result;
12247     PyObject * obj0 = 0 ;
12248     char *kwnames[] = {
12249         (char *) "self", NULL
12250     };
12251
12252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetPageSize",kwnames,&obj0)) goto fail;
12253     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12254     if (SWIG_arg_fail(1)) SWIG_fail;
12255     {
12256         PyThreadState* __tstate = wxPyBeginAllowThreads();
12257         result = (int)((wxScrollBar const *)arg1)->GetPageSize();
12258
12259         wxPyEndAllowThreads(__tstate);
12260         if (PyErr_Occurred()) SWIG_fail;
12261     }
12262     {
12263         resultobj = SWIG_From_int((int)(result));
12264     }
12265     return resultobj;
12266     fail:
12267     return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_ScrollBar_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
12272     PyObject *resultobj;
12273     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12274     int result;
12275     PyObject * obj0 = 0 ;
12276     char *kwnames[] = {
12277         (char *) "self", NULL
12278     };
12279
12280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetRange",kwnames,&obj0)) goto fail;
12281     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12282     if (SWIG_arg_fail(1)) SWIG_fail;
12283     {
12284         PyThreadState* __tstate = wxPyBeginAllowThreads();
12285         result = (int)((wxScrollBar const *)arg1)->GetRange();
12286
12287         wxPyEndAllowThreads(__tstate);
12288         if (PyErr_Occurred()) SWIG_fail;
12289     }
12290     {
12291         resultobj = SWIG_From_int((int)(result));
12292     }
12293     return resultobj;
12294     fail:
12295     return NULL;
12296 }
12297
12298
12299 static PyObject *_wrap_ScrollBar_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
12300     PyObject *resultobj;
12301     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12302     bool result;
12303     PyObject * obj0 = 0 ;
12304     char *kwnames[] = {
12305         (char *) "self", NULL
12306     };
12307
12308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_IsVertical",kwnames,&obj0)) goto fail;
12309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12310     if (SWIG_arg_fail(1)) SWIG_fail;
12311     {
12312         PyThreadState* __tstate = wxPyBeginAllowThreads();
12313         result = (bool)((wxScrollBar const *)arg1)->IsVertical();
12314
12315         wxPyEndAllowThreads(__tstate);
12316         if (PyErr_Occurred()) SWIG_fail;
12317     }
12318     {
12319         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12320     }
12321     return resultobj;
12322     fail:
12323     return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_ScrollBar_SetThumbPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12328     PyObject *resultobj;
12329     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12330     int arg2 ;
12331     PyObject * obj0 = 0 ;
12332     PyObject * obj1 = 0 ;
12333     char *kwnames[] = {
12334         (char *) "self",(char *) "viewStart", NULL
12335     };
12336
12337     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollBar_SetThumbPosition",kwnames,&obj0,&obj1)) goto fail;
12338     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12339     if (SWIG_arg_fail(1)) SWIG_fail;
12340     {
12341         arg2 = (int)(SWIG_As_int(obj1));
12342         if (SWIG_arg_fail(2)) SWIG_fail;
12343     }
12344     {
12345         PyThreadState* __tstate = wxPyBeginAllowThreads();
12346         (arg1)->SetThumbPosition(arg2);
12347
12348         wxPyEndAllowThreads(__tstate);
12349         if (PyErr_Occurred()) SWIG_fail;
12350     }
12351     Py_INCREF(Py_None); resultobj = Py_None;
12352     return resultobj;
12353     fail:
12354     return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_ScrollBar_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
12359     PyObject *resultobj;
12360     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12361     int arg2 ;
12362     int arg3 ;
12363     int arg4 ;
12364     int arg5 ;
12365     bool arg6 = (bool) true ;
12366     PyObject * obj0 = 0 ;
12367     PyObject * obj1 = 0 ;
12368     PyObject * obj2 = 0 ;
12369     PyObject * obj3 = 0 ;
12370     PyObject * obj4 = 0 ;
12371     PyObject * obj5 = 0 ;
12372     char *kwnames[] = {
12373         (char *) "self",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "pageSize",(char *) "refresh", NULL
12374     };
12375
12376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:ScrollBar_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12378     if (SWIG_arg_fail(1)) SWIG_fail;
12379     {
12380         arg2 = (int)(SWIG_As_int(obj1));
12381         if (SWIG_arg_fail(2)) SWIG_fail;
12382     }
12383     {
12384         arg3 = (int)(SWIG_As_int(obj2));
12385         if (SWIG_arg_fail(3)) SWIG_fail;
12386     }
12387     {
12388         arg4 = (int)(SWIG_As_int(obj3));
12389         if (SWIG_arg_fail(4)) SWIG_fail;
12390     }
12391     {
12392         arg5 = (int)(SWIG_As_int(obj4));
12393         if (SWIG_arg_fail(5)) SWIG_fail;
12394     }
12395     if (obj5) {
12396         {
12397             arg6 = (bool)(SWIG_As_bool(obj5));
12398             if (SWIG_arg_fail(6)) SWIG_fail;
12399         }
12400     }
12401     {
12402         PyThreadState* __tstate = wxPyBeginAllowThreads();
12403         (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
12404
12405         wxPyEndAllowThreads(__tstate);
12406         if (PyErr_Occurred()) SWIG_fail;
12407     }
12408     Py_INCREF(Py_None); resultobj = Py_None;
12409     return resultobj;
12410     fail:
12411     return NULL;
12412 }
12413
12414
12415 static PyObject *_wrap_ScrollBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
12416     PyObject *resultobj;
12417     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
12418     wxVisualAttributes result;
12419     PyObject * obj0 = 0 ;
12420     char *kwnames[] = {
12421         (char *) "variant", NULL
12422     };
12423
12424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrollBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
12425     if (obj0) {
12426         {
12427             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
12428             if (SWIG_arg_fail(1)) SWIG_fail;
12429         }
12430     }
12431     {
12432         if (!wxPyCheckForApp()) SWIG_fail;
12433         PyThreadState* __tstate = wxPyBeginAllowThreads();
12434         result = wxScrollBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
12435
12436         wxPyEndAllowThreads(__tstate);
12437         if (PyErr_Occurred()) SWIG_fail;
12438     }
12439     {
12440         wxVisualAttributes * resultptr;
12441         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
12442         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
12443     }
12444     return resultobj;
12445     fail:
12446     return NULL;
12447 }
12448
12449
12450 static PyObject * ScrollBar_swigregister(PyObject *, PyObject *args) {
12451     PyObject *obj;
12452     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12453     SWIG_TypeClientData(SWIGTYPE_p_wxScrollBar, obj);
12454     Py_INCREF(obj);
12455     return Py_BuildValue((char *)"");
12456 }
12457 static int _wrap_SPIN_BUTTON_NAME_set(PyObject *) {
12458     PyErr_SetString(PyExc_TypeError,"Variable SPIN_BUTTON_NAME is read-only.");
12459     return 1;
12460 }
12461
12462
12463 static PyObject *_wrap_SPIN_BUTTON_NAME_get(void) {
12464     PyObject *pyobj;
12465
12466     {
12467 #if wxUSE_UNICODE
12468         pyobj = PyUnicode_FromWideChar((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
12469 #else
12470         pyobj = PyString_FromStringAndSize((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
12471 #endif
12472     }
12473     return pyobj;
12474 }
12475
12476
12477 static int _wrap_SpinCtrlNameStr_set(PyObject *) {
12478     PyErr_SetString(PyExc_TypeError,"Variable SpinCtrlNameStr is read-only.");
12479     return 1;
12480 }
12481
12482
12483 static PyObject *_wrap_SpinCtrlNameStr_get(void) {
12484     PyObject *pyobj;
12485
12486     {
12487 #if wxUSE_UNICODE
12488         pyobj = PyUnicode_FromWideChar((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
12489 #else
12490         pyobj = PyString_FromStringAndSize((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
12491 #endif
12492     }
12493     return pyobj;
12494 }
12495
12496
12497 static PyObject *_wrap_new_SpinButton(PyObject *, PyObject *args, PyObject *kwargs) {
12498     PyObject *resultobj;
12499     wxWindow *arg1 = (wxWindow *) 0 ;
12500     int arg2 = (int) -1 ;
12501     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12502     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12503     wxSize const &arg4_defvalue = wxDefaultSize ;
12504     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12505     long arg5 = (long) wxSP_HORIZONTAL ;
12506     wxString const &arg6_defvalue = wxPySPIN_BUTTON_NAME ;
12507     wxString *arg6 = (wxString *) &arg6_defvalue ;
12508     wxSpinButton *result;
12509     wxPoint temp3 ;
12510     wxSize temp4 ;
12511     bool temp6 = false ;
12512     PyObject * obj0 = 0 ;
12513     PyObject * obj1 = 0 ;
12514     PyObject * obj2 = 0 ;
12515     PyObject * obj3 = 0 ;
12516     PyObject * obj4 = 0 ;
12517     PyObject * obj5 = 0 ;
12518     char *kwnames[] = {
12519         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12520     };
12521
12522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SpinButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12523     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12524     if (SWIG_arg_fail(1)) SWIG_fail;
12525     if (obj1) {
12526         {
12527             arg2 = (int)(SWIG_As_int(obj1));
12528             if (SWIG_arg_fail(2)) SWIG_fail;
12529         }
12530     }
12531     if (obj2) {
12532         {
12533             arg3 = &temp3;
12534             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12535         }
12536     }
12537     if (obj3) {
12538         {
12539             arg4 = &temp4;
12540             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12541         }
12542     }
12543     if (obj4) {
12544         {
12545             arg5 = (long)(SWIG_As_long(obj4));
12546             if (SWIG_arg_fail(5)) SWIG_fail;
12547         }
12548     }
12549     if (obj5) {
12550         {
12551             arg6 = wxString_in_helper(obj5);
12552             if (arg6 == NULL) SWIG_fail;
12553             temp6 = true;
12554         }
12555     }
12556     {
12557         if (!wxPyCheckForApp()) SWIG_fail;
12558         PyThreadState* __tstate = wxPyBeginAllowThreads();
12559         result = (wxSpinButton *)new wxSpinButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12560
12561         wxPyEndAllowThreads(__tstate);
12562         if (PyErr_Occurred()) SWIG_fail;
12563     }
12564     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinButton, 1);
12565     {
12566         if (temp6)
12567         delete arg6;
12568     }
12569     return resultobj;
12570     fail:
12571     {
12572         if (temp6)
12573         delete arg6;
12574     }
12575     return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_new_PreSpinButton(PyObject *, PyObject *args, PyObject *kwargs) {
12580     PyObject *resultobj;
12581     wxSpinButton *result;
12582     char *kwnames[] = {
12583         NULL
12584     };
12585
12586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSpinButton",kwnames)) goto fail;
12587     {
12588         if (!wxPyCheckForApp()) SWIG_fail;
12589         PyThreadState* __tstate = wxPyBeginAllowThreads();
12590         result = (wxSpinButton *)new wxSpinButton();
12591
12592         wxPyEndAllowThreads(__tstate);
12593         if (PyErr_Occurred()) SWIG_fail;
12594     }
12595     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinButton, 1);
12596     return resultobj;
12597     fail:
12598     return NULL;
12599 }
12600
12601
12602 static PyObject *_wrap_SpinButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12603     PyObject *resultobj;
12604     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12605     wxWindow *arg2 = (wxWindow *) 0 ;
12606     int arg3 = (int) -1 ;
12607     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12608     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12609     wxSize const &arg5_defvalue = wxDefaultSize ;
12610     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12611     long arg6 = (long) wxSP_HORIZONTAL ;
12612     wxString const &arg7_defvalue = wxPySPIN_BUTTON_NAME ;
12613     wxString *arg7 = (wxString *) &arg7_defvalue ;
12614     bool result;
12615     wxPoint temp4 ;
12616     wxSize temp5 ;
12617     bool temp7 = false ;
12618     PyObject * obj0 = 0 ;
12619     PyObject * obj1 = 0 ;
12620     PyObject * obj2 = 0 ;
12621     PyObject * obj3 = 0 ;
12622     PyObject * obj4 = 0 ;
12623     PyObject * obj5 = 0 ;
12624     PyObject * obj6 = 0 ;
12625     char *kwnames[] = {
12626         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12627     };
12628
12629     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SpinButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12630     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12631     if (SWIG_arg_fail(1)) SWIG_fail;
12632     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12633     if (SWIG_arg_fail(2)) SWIG_fail;
12634     if (obj2) {
12635         {
12636             arg3 = (int)(SWIG_As_int(obj2));
12637             if (SWIG_arg_fail(3)) SWIG_fail;
12638         }
12639     }
12640     if (obj3) {
12641         {
12642             arg4 = &temp4;
12643             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12644         }
12645     }
12646     if (obj4) {
12647         {
12648             arg5 = &temp5;
12649             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12650         }
12651     }
12652     if (obj5) {
12653         {
12654             arg6 = (long)(SWIG_As_long(obj5));
12655             if (SWIG_arg_fail(6)) SWIG_fail;
12656         }
12657     }
12658     if (obj6) {
12659         {
12660             arg7 = wxString_in_helper(obj6);
12661             if (arg7 == NULL) SWIG_fail;
12662             temp7 = true;
12663         }
12664     }
12665     {
12666         PyThreadState* __tstate = wxPyBeginAllowThreads();
12667         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12668
12669         wxPyEndAllowThreads(__tstate);
12670         if (PyErr_Occurred()) SWIG_fail;
12671     }
12672     {
12673         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12674     }
12675     {
12676         if (temp7)
12677         delete arg7;
12678     }
12679     return resultobj;
12680     fail:
12681     {
12682         if (temp7)
12683         delete arg7;
12684     }
12685     return NULL;
12686 }
12687
12688
12689 static PyObject *_wrap_SpinButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
12690     PyObject *resultobj;
12691     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12692     int result;
12693     PyObject * obj0 = 0 ;
12694     char *kwnames[] = {
12695         (char *) "self", NULL
12696     };
12697
12698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetValue",kwnames,&obj0)) goto fail;
12699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12700     if (SWIG_arg_fail(1)) SWIG_fail;
12701     {
12702         PyThreadState* __tstate = wxPyBeginAllowThreads();
12703         result = (int)((wxSpinButton const *)arg1)->GetValue();
12704
12705         wxPyEndAllowThreads(__tstate);
12706         if (PyErr_Occurred()) SWIG_fail;
12707     }
12708     {
12709         resultobj = SWIG_From_int((int)(result));
12710     }
12711     return resultobj;
12712     fail:
12713     return NULL;
12714 }
12715
12716
12717 static PyObject *_wrap_SpinButton_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
12718     PyObject *resultobj;
12719     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12720     int result;
12721     PyObject * obj0 = 0 ;
12722     char *kwnames[] = {
12723         (char *) "self", NULL
12724     };
12725
12726     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetMin",kwnames,&obj0)) goto fail;
12727     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12728     if (SWIG_arg_fail(1)) SWIG_fail;
12729     {
12730         PyThreadState* __tstate = wxPyBeginAllowThreads();
12731         result = (int)((wxSpinButton const *)arg1)->GetMin();
12732
12733         wxPyEndAllowThreads(__tstate);
12734         if (PyErr_Occurred()) SWIG_fail;
12735     }
12736     {
12737         resultobj = SWIG_From_int((int)(result));
12738     }
12739     return resultobj;
12740     fail:
12741     return NULL;
12742 }
12743
12744
12745 static PyObject *_wrap_SpinButton_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
12746     PyObject *resultobj;
12747     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12748     int result;
12749     PyObject * obj0 = 0 ;
12750     char *kwnames[] = {
12751         (char *) "self", NULL
12752     };
12753
12754     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetMax",kwnames,&obj0)) goto fail;
12755     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12756     if (SWIG_arg_fail(1)) SWIG_fail;
12757     {
12758         PyThreadState* __tstate = wxPyBeginAllowThreads();
12759         result = (int)((wxSpinButton const *)arg1)->GetMax();
12760
12761         wxPyEndAllowThreads(__tstate);
12762         if (PyErr_Occurred()) SWIG_fail;
12763     }
12764     {
12765         resultobj = SWIG_From_int((int)(result));
12766     }
12767     return resultobj;
12768     fail:
12769     return NULL;
12770 }
12771
12772
12773 static PyObject *_wrap_SpinButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
12774     PyObject *resultobj;
12775     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12776     int arg2 ;
12777     PyObject * obj0 = 0 ;
12778     PyObject * obj1 = 0 ;
12779     char *kwnames[] = {
12780         (char *) "self",(char *) "val", NULL
12781     };
12782
12783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
12784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12785     if (SWIG_arg_fail(1)) SWIG_fail;
12786     {
12787         arg2 = (int)(SWIG_As_int(obj1));
12788         if (SWIG_arg_fail(2)) SWIG_fail;
12789     }
12790     {
12791         PyThreadState* __tstate = wxPyBeginAllowThreads();
12792         (arg1)->SetValue(arg2);
12793
12794         wxPyEndAllowThreads(__tstate);
12795         if (PyErr_Occurred()) SWIG_fail;
12796     }
12797     Py_INCREF(Py_None); resultobj = Py_None;
12798     return resultobj;
12799     fail:
12800     return NULL;
12801 }
12802
12803
12804 static PyObject *_wrap_SpinButton_SetMin(PyObject *, PyObject *args, PyObject *kwargs) {
12805     PyObject *resultobj;
12806     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12807     int arg2 ;
12808     PyObject * obj0 = 0 ;
12809     PyObject * obj1 = 0 ;
12810     char *kwnames[] = {
12811         (char *) "self",(char *) "minVal", NULL
12812     };
12813
12814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMin",kwnames,&obj0,&obj1)) goto fail;
12815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12816     if (SWIG_arg_fail(1)) SWIG_fail;
12817     {
12818         arg2 = (int)(SWIG_As_int(obj1));
12819         if (SWIG_arg_fail(2)) SWIG_fail;
12820     }
12821     {
12822         PyThreadState* __tstate = wxPyBeginAllowThreads();
12823         (arg1)->SetMin(arg2);
12824
12825         wxPyEndAllowThreads(__tstate);
12826         if (PyErr_Occurred()) SWIG_fail;
12827     }
12828     Py_INCREF(Py_None); resultobj = Py_None;
12829     return resultobj;
12830     fail:
12831     return NULL;
12832 }
12833
12834
12835 static PyObject *_wrap_SpinButton_SetMax(PyObject *, PyObject *args, PyObject *kwargs) {
12836     PyObject *resultobj;
12837     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12838     int arg2 ;
12839     PyObject * obj0 = 0 ;
12840     PyObject * obj1 = 0 ;
12841     char *kwnames[] = {
12842         (char *) "self",(char *) "maxVal", NULL
12843     };
12844
12845     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMax",kwnames,&obj0,&obj1)) goto fail;
12846     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12847     if (SWIG_arg_fail(1)) SWIG_fail;
12848     {
12849         arg2 = (int)(SWIG_As_int(obj1));
12850         if (SWIG_arg_fail(2)) SWIG_fail;
12851     }
12852     {
12853         PyThreadState* __tstate = wxPyBeginAllowThreads();
12854         (arg1)->SetMax(arg2);
12855
12856         wxPyEndAllowThreads(__tstate);
12857         if (PyErr_Occurred()) SWIG_fail;
12858     }
12859     Py_INCREF(Py_None); resultobj = Py_None;
12860     return resultobj;
12861     fail:
12862     return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_SpinButton_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
12867     PyObject *resultobj;
12868     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12869     int arg2 ;
12870     int arg3 ;
12871     PyObject * obj0 = 0 ;
12872     PyObject * obj1 = 0 ;
12873     PyObject * obj2 = 0 ;
12874     char *kwnames[] = {
12875         (char *) "self",(char *) "minVal",(char *) "maxVal", NULL
12876     };
12877
12878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinButton_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12880     if (SWIG_arg_fail(1)) SWIG_fail;
12881     {
12882         arg2 = (int)(SWIG_As_int(obj1));
12883         if (SWIG_arg_fail(2)) SWIG_fail;
12884     }
12885     {
12886         arg3 = (int)(SWIG_As_int(obj2));
12887         if (SWIG_arg_fail(3)) SWIG_fail;
12888     }
12889     {
12890         PyThreadState* __tstate = wxPyBeginAllowThreads();
12891         (arg1)->SetRange(arg2,arg3);
12892
12893         wxPyEndAllowThreads(__tstate);
12894         if (PyErr_Occurred()) SWIG_fail;
12895     }
12896     Py_INCREF(Py_None); resultobj = Py_None;
12897     return resultobj;
12898     fail:
12899     return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_SpinButton_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
12904     PyObject *resultobj;
12905     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12906     bool result;
12907     PyObject * obj0 = 0 ;
12908     char *kwnames[] = {
12909         (char *) "self", NULL
12910     };
12911
12912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_IsVertical",kwnames,&obj0)) goto fail;
12913     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12914     if (SWIG_arg_fail(1)) SWIG_fail;
12915     {
12916         PyThreadState* __tstate = wxPyBeginAllowThreads();
12917         result = (bool)((wxSpinButton const *)arg1)->IsVertical();
12918
12919         wxPyEndAllowThreads(__tstate);
12920         if (PyErr_Occurred()) SWIG_fail;
12921     }
12922     {
12923         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12924     }
12925     return resultobj;
12926     fail:
12927     return NULL;
12928 }
12929
12930
12931 static PyObject *_wrap_SpinButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
12932     PyObject *resultobj;
12933     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
12934     wxVisualAttributes result;
12935     PyObject * obj0 = 0 ;
12936     char *kwnames[] = {
12937         (char *) "variant", NULL
12938     };
12939
12940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
12941     if (obj0) {
12942         {
12943             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
12944             if (SWIG_arg_fail(1)) SWIG_fail;
12945         }
12946     }
12947     {
12948         if (!wxPyCheckForApp()) SWIG_fail;
12949         PyThreadState* __tstate = wxPyBeginAllowThreads();
12950         result = wxSpinButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
12951
12952         wxPyEndAllowThreads(__tstate);
12953         if (PyErr_Occurred()) SWIG_fail;
12954     }
12955     {
12956         wxVisualAttributes * resultptr;
12957         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
12958         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
12959     }
12960     return resultobj;
12961     fail:
12962     return NULL;
12963 }
12964
12965
12966 static PyObject * SpinButton_swigregister(PyObject *, PyObject *args) {
12967     PyObject *obj;
12968     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12969     SWIG_TypeClientData(SWIGTYPE_p_wxSpinButton, obj);
12970     Py_INCREF(obj);
12971     return Py_BuildValue((char *)"");
12972 }
12973 static PyObject *_wrap_new_SpinCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
12974     PyObject *resultobj;
12975     wxWindow *arg1 = (wxWindow *) 0 ;
12976     int arg2 = (int) -1 ;
12977     wxString const &arg3_defvalue = wxPyEmptyString ;
12978     wxString *arg3 = (wxString *) &arg3_defvalue ;
12979     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12980     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12981     wxSize const &arg5_defvalue = wxDefaultSize ;
12982     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12983     long arg6 = (long) wxSP_ARROW_KEYS ;
12984     int arg7 = (int) 0 ;
12985     int arg8 = (int) 100 ;
12986     int arg9 = (int) 0 ;
12987     wxString const &arg10_defvalue = wxPySpinCtrlNameStr ;
12988     wxString *arg10 = (wxString *) &arg10_defvalue ;
12989     wxSpinCtrl *result;
12990     bool temp3 = false ;
12991     wxPoint temp4 ;
12992     wxSize temp5 ;
12993     bool temp10 = false ;
12994     PyObject * obj0 = 0 ;
12995     PyObject * obj1 = 0 ;
12996     PyObject * obj2 = 0 ;
12997     PyObject * obj3 = 0 ;
12998     PyObject * obj4 = 0 ;
12999     PyObject * obj5 = 0 ;
13000     PyObject * obj6 = 0 ;
13001     PyObject * obj7 = 0 ;
13002     PyObject * obj8 = 0 ;
13003     PyObject * obj9 = 0 ;
13004     char *kwnames[] = {
13005         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL
13006     };
13007
13008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_SpinCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
13009     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13010     if (SWIG_arg_fail(1)) SWIG_fail;
13011     if (obj1) {
13012         {
13013             arg2 = (int)(SWIG_As_int(obj1));
13014             if (SWIG_arg_fail(2)) SWIG_fail;
13015         }
13016     }
13017     if (obj2) {
13018         {
13019             arg3 = wxString_in_helper(obj2);
13020             if (arg3 == NULL) SWIG_fail;
13021             temp3 = true;
13022         }
13023     }
13024     if (obj3) {
13025         {
13026             arg4 = &temp4;
13027             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13028         }
13029     }
13030     if (obj4) {
13031         {
13032             arg5 = &temp5;
13033             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
13034         }
13035     }
13036     if (obj5) {
13037         {
13038             arg6 = (long)(SWIG_As_long(obj5));
13039             if (SWIG_arg_fail(6)) SWIG_fail;
13040         }
13041     }
13042     if (obj6) {
13043         {
13044             arg7 = (int)(SWIG_As_int(obj6));
13045             if (SWIG_arg_fail(7)) SWIG_fail;
13046         }
13047     }
13048     if (obj7) {
13049         {
13050             arg8 = (int)(SWIG_As_int(obj7));
13051             if (SWIG_arg_fail(8)) SWIG_fail;
13052         }
13053     }
13054     if (obj8) {
13055         {
13056             arg9 = (int)(SWIG_As_int(obj8));
13057             if (SWIG_arg_fail(9)) SWIG_fail;
13058         }
13059     }
13060     if (obj9) {
13061         {
13062             arg10 = wxString_in_helper(obj9);
13063             if (arg10 == NULL) SWIG_fail;
13064             temp10 = true;
13065         }
13066     }
13067     {
13068         if (!wxPyCheckForApp()) SWIG_fail;
13069         PyThreadState* __tstate = wxPyBeginAllowThreads();
13070         result = (wxSpinCtrl *)new wxSpinCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,arg7,arg8,arg9,(wxString const &)*arg10);
13071
13072         wxPyEndAllowThreads(__tstate);
13073         if (PyErr_Occurred()) SWIG_fail;
13074     }
13075     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinCtrl, 1);
13076     {
13077         if (temp3)
13078         delete arg3;
13079     }
13080     {
13081         if (temp10)
13082         delete arg10;
13083     }
13084     return resultobj;
13085     fail:
13086     {
13087         if (temp3)
13088         delete arg3;
13089     }
13090     {
13091         if (temp10)
13092         delete arg10;
13093     }
13094     return NULL;
13095 }
13096
13097
13098 static PyObject *_wrap_new_PreSpinCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
13099     PyObject *resultobj;
13100     wxSpinCtrl *result;
13101     char *kwnames[] = {
13102         NULL
13103     };
13104
13105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSpinCtrl",kwnames)) goto fail;
13106     {
13107         if (!wxPyCheckForApp()) SWIG_fail;
13108         PyThreadState* __tstate = wxPyBeginAllowThreads();
13109         result = (wxSpinCtrl *)new wxSpinCtrl();
13110
13111         wxPyEndAllowThreads(__tstate);
13112         if (PyErr_Occurred()) SWIG_fail;
13113     }
13114     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinCtrl, 1);
13115     return resultobj;
13116     fail:
13117     return NULL;
13118 }
13119
13120
13121 static PyObject *_wrap_SpinCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13122     PyObject *resultobj;
13123     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13124     wxWindow *arg2 = (wxWindow *) 0 ;
13125     int arg3 = (int) -1 ;
13126     wxString const &arg4_defvalue = wxPyEmptyString ;
13127     wxString *arg4 = (wxString *) &arg4_defvalue ;
13128     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13129     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13130     wxSize const &arg6_defvalue = wxDefaultSize ;
13131     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13132     long arg7 = (long) wxSP_ARROW_KEYS ;
13133     int arg8 = (int) 0 ;
13134     int arg9 = (int) 100 ;
13135     int arg10 = (int) 0 ;
13136     wxString const &arg11_defvalue = wxPySpinCtrlNameStr ;
13137     wxString *arg11 = (wxString *) &arg11_defvalue ;
13138     bool result;
13139     bool temp4 = false ;
13140     wxPoint temp5 ;
13141     wxSize temp6 ;
13142     bool temp11 = false ;
13143     PyObject * obj0 = 0 ;
13144     PyObject * obj1 = 0 ;
13145     PyObject * obj2 = 0 ;
13146     PyObject * obj3 = 0 ;
13147     PyObject * obj4 = 0 ;
13148     PyObject * obj5 = 0 ;
13149     PyObject * obj6 = 0 ;
13150     PyObject * obj7 = 0 ;
13151     PyObject * obj8 = 0 ;
13152     PyObject * obj9 = 0 ;
13153     PyObject * obj10 = 0 ;
13154     char *kwnames[] = {
13155         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL
13156     };
13157
13158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:SpinCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
13159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13160     if (SWIG_arg_fail(1)) SWIG_fail;
13161     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13162     if (SWIG_arg_fail(2)) SWIG_fail;
13163     if (obj2) {
13164         {
13165             arg3 = (int)(SWIG_As_int(obj2));
13166             if (SWIG_arg_fail(3)) SWIG_fail;
13167         }
13168     }
13169     if (obj3) {
13170         {
13171             arg4 = wxString_in_helper(obj3);
13172             if (arg4 == NULL) SWIG_fail;
13173             temp4 = true;
13174         }
13175     }
13176     if (obj4) {
13177         {
13178             arg5 = &temp5;
13179             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13180         }
13181     }
13182     if (obj5) {
13183         {
13184             arg6 = &temp6;
13185             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13186         }
13187     }
13188     if (obj6) {
13189         {
13190             arg7 = (long)(SWIG_As_long(obj6));
13191             if (SWIG_arg_fail(7)) SWIG_fail;
13192         }
13193     }
13194     if (obj7) {
13195         {
13196             arg8 = (int)(SWIG_As_int(obj7));
13197             if (SWIG_arg_fail(8)) SWIG_fail;
13198         }
13199     }
13200     if (obj8) {
13201         {
13202             arg9 = (int)(SWIG_As_int(obj8));
13203             if (SWIG_arg_fail(9)) SWIG_fail;
13204         }
13205     }
13206     if (obj9) {
13207         {
13208             arg10 = (int)(SWIG_As_int(obj9));
13209             if (SWIG_arg_fail(10)) SWIG_fail;
13210         }
13211     }
13212     if (obj10) {
13213         {
13214             arg11 = wxString_in_helper(obj10);
13215             if (arg11 == NULL) SWIG_fail;
13216             temp11 = true;
13217         }
13218     }
13219     {
13220         PyThreadState* __tstate = wxPyBeginAllowThreads();
13221         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,arg8,arg9,arg10,(wxString const &)*arg11);
13222
13223         wxPyEndAllowThreads(__tstate);
13224         if (PyErr_Occurred()) SWIG_fail;
13225     }
13226     {
13227         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13228     }
13229     {
13230         if (temp4)
13231         delete arg4;
13232     }
13233     {
13234         if (temp11)
13235         delete arg11;
13236     }
13237     return resultobj;
13238     fail:
13239     {
13240         if (temp4)
13241         delete arg4;
13242     }
13243     {
13244         if (temp11)
13245         delete arg11;
13246     }
13247     return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_SpinCtrl_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
13252     PyObject *resultobj;
13253     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13254     int result;
13255     PyObject * obj0 = 0 ;
13256     char *kwnames[] = {
13257         (char *) "self", NULL
13258     };
13259
13260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetValue",kwnames,&obj0)) goto fail;
13261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13262     if (SWIG_arg_fail(1)) SWIG_fail;
13263     {
13264         PyThreadState* __tstate = wxPyBeginAllowThreads();
13265         result = (int)((wxSpinCtrl const *)arg1)->GetValue();
13266
13267         wxPyEndAllowThreads(__tstate);
13268         if (PyErr_Occurred()) SWIG_fail;
13269     }
13270     {
13271         resultobj = SWIG_From_int((int)(result));
13272     }
13273     return resultobj;
13274     fail:
13275     return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_SpinCtrl_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
13280     PyObject *resultobj;
13281     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13282     int arg2 ;
13283     PyObject * obj0 = 0 ;
13284     PyObject * obj1 = 0 ;
13285     char *kwnames[] = {
13286         (char *) "self",(char *) "value", NULL
13287     };
13288
13289     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValue",kwnames,&obj0,&obj1)) goto fail;
13290     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13291     if (SWIG_arg_fail(1)) SWIG_fail;
13292     {
13293         arg2 = (int)(SWIG_As_int(obj1));
13294         if (SWIG_arg_fail(2)) SWIG_fail;
13295     }
13296     {
13297         PyThreadState* __tstate = wxPyBeginAllowThreads();
13298         (arg1)->SetValue(arg2);
13299
13300         wxPyEndAllowThreads(__tstate);
13301         if (PyErr_Occurred()) SWIG_fail;
13302     }
13303     Py_INCREF(Py_None); resultobj = Py_None;
13304     return resultobj;
13305     fail:
13306     return NULL;
13307 }
13308
13309
13310 static PyObject *_wrap_SpinCtrl_SetValueString(PyObject *, PyObject *args, PyObject *kwargs) {
13311     PyObject *resultobj;
13312     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13313     wxString *arg2 = 0 ;
13314     bool temp2 = false ;
13315     PyObject * obj0 = 0 ;
13316     PyObject * obj1 = 0 ;
13317     char *kwnames[] = {
13318         (char *) "self",(char *) "text", NULL
13319     };
13320
13321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValueString",kwnames,&obj0,&obj1)) goto fail;
13322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13323     if (SWIG_arg_fail(1)) SWIG_fail;
13324     {
13325         arg2 = wxString_in_helper(obj1);
13326         if (arg2 == NULL) SWIG_fail;
13327         temp2 = true;
13328     }
13329     {
13330         PyThreadState* __tstate = wxPyBeginAllowThreads();
13331         (arg1)->SetValue((wxString const &)*arg2);
13332
13333         wxPyEndAllowThreads(__tstate);
13334         if (PyErr_Occurred()) SWIG_fail;
13335     }
13336     Py_INCREF(Py_None); resultobj = Py_None;
13337     {
13338         if (temp2)
13339         delete arg2;
13340     }
13341     return resultobj;
13342     fail:
13343     {
13344         if (temp2)
13345         delete arg2;
13346     }
13347     return NULL;
13348 }
13349
13350
13351 static PyObject *_wrap_SpinCtrl_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
13352     PyObject *resultobj;
13353     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13354     int arg2 ;
13355     int arg3 ;
13356     PyObject * obj0 = 0 ;
13357     PyObject * obj1 = 0 ;
13358     PyObject * obj2 = 0 ;
13359     char *kwnames[] = {
13360         (char *) "self",(char *) "minVal",(char *) "maxVal", NULL
13361     };
13362
13363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
13364     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13365     if (SWIG_arg_fail(1)) SWIG_fail;
13366     {
13367         arg2 = (int)(SWIG_As_int(obj1));
13368         if (SWIG_arg_fail(2)) SWIG_fail;
13369     }
13370     {
13371         arg3 = (int)(SWIG_As_int(obj2));
13372         if (SWIG_arg_fail(3)) SWIG_fail;
13373     }
13374     {
13375         PyThreadState* __tstate = wxPyBeginAllowThreads();
13376         (arg1)->SetRange(arg2,arg3);
13377
13378         wxPyEndAllowThreads(__tstate);
13379         if (PyErr_Occurred()) SWIG_fail;
13380     }
13381     Py_INCREF(Py_None); resultobj = Py_None;
13382     return resultobj;
13383     fail:
13384     return NULL;
13385 }
13386
13387
13388 static PyObject *_wrap_SpinCtrl_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
13389     PyObject *resultobj;
13390     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13391     int result;
13392     PyObject * obj0 = 0 ;
13393     char *kwnames[] = {
13394         (char *) "self", NULL
13395     };
13396
13397     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetMin",kwnames,&obj0)) goto fail;
13398     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13399     if (SWIG_arg_fail(1)) SWIG_fail;
13400     {
13401         PyThreadState* __tstate = wxPyBeginAllowThreads();
13402         result = (int)((wxSpinCtrl const *)arg1)->GetMin();
13403
13404         wxPyEndAllowThreads(__tstate);
13405         if (PyErr_Occurred()) SWIG_fail;
13406     }
13407     {
13408         resultobj = SWIG_From_int((int)(result));
13409     }
13410     return resultobj;
13411     fail:
13412     return NULL;
13413 }
13414
13415
13416 static PyObject *_wrap_SpinCtrl_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
13417     PyObject *resultobj;
13418     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13419     int result;
13420     PyObject * obj0 = 0 ;
13421     char *kwnames[] = {
13422         (char *) "self", NULL
13423     };
13424
13425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetMax",kwnames,&obj0)) goto fail;
13426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13427     if (SWIG_arg_fail(1)) SWIG_fail;
13428     {
13429         PyThreadState* __tstate = wxPyBeginAllowThreads();
13430         result = (int)((wxSpinCtrl const *)arg1)->GetMax();
13431
13432         wxPyEndAllowThreads(__tstate);
13433         if (PyErr_Occurred()) SWIG_fail;
13434     }
13435     {
13436         resultobj = SWIG_From_int((int)(result));
13437     }
13438     return resultobj;
13439     fail:
13440     return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_SpinCtrl_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
13445     PyObject *resultobj;
13446     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13447     long arg2 ;
13448     long arg3 ;
13449     PyObject * obj0 = 0 ;
13450     PyObject * obj1 = 0 ;
13451     PyObject * obj2 = 0 ;
13452     char *kwnames[] = {
13453         (char *) "self",(char *) "from",(char *) "to", NULL
13454     };
13455
13456     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
13457     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13458     if (SWIG_arg_fail(1)) SWIG_fail;
13459     {
13460         arg2 = (long)(SWIG_As_long(obj1));
13461         if (SWIG_arg_fail(2)) SWIG_fail;
13462     }
13463     {
13464         arg3 = (long)(SWIG_As_long(obj2));
13465         if (SWIG_arg_fail(3)) SWIG_fail;
13466     }
13467     {
13468         PyThreadState* __tstate = wxPyBeginAllowThreads();
13469         (arg1)->SetSelection(arg2,arg3);
13470
13471         wxPyEndAllowThreads(__tstate);
13472         if (PyErr_Occurred()) SWIG_fail;
13473     }
13474     Py_INCREF(Py_None); resultobj = Py_None;
13475     return resultobj;
13476     fail:
13477     return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_SpinCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
13482     PyObject *resultobj;
13483     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
13484     wxVisualAttributes result;
13485     PyObject * obj0 = 0 ;
13486     char *kwnames[] = {
13487         (char *) "variant", NULL
13488     };
13489
13490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
13491     if (obj0) {
13492         {
13493             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
13494             if (SWIG_arg_fail(1)) SWIG_fail;
13495         }
13496     }
13497     {
13498         if (!wxPyCheckForApp()) SWIG_fail;
13499         PyThreadState* __tstate = wxPyBeginAllowThreads();
13500         result = wxSpinCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
13501
13502         wxPyEndAllowThreads(__tstate);
13503         if (PyErr_Occurred()) SWIG_fail;
13504     }
13505     {
13506         wxVisualAttributes * resultptr;
13507         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
13508         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
13509     }
13510     return resultobj;
13511     fail:
13512     return NULL;
13513 }
13514
13515
13516 static PyObject * SpinCtrl_swigregister(PyObject *, PyObject *args) {
13517     PyObject *obj;
13518     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13519     SWIG_TypeClientData(SWIGTYPE_p_wxSpinCtrl, obj);
13520     Py_INCREF(obj);
13521     return Py_BuildValue((char *)"");
13522 }
13523 static PyObject *_wrap_new_SpinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13524     PyObject *resultobj;
13525     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13526     int arg2 = (int) 0 ;
13527     wxSpinEvent *result;
13528     PyObject * obj0 = 0 ;
13529     PyObject * obj1 = 0 ;
13530     char *kwnames[] = {
13531         (char *) "commandType",(char *) "winid", NULL
13532     };
13533
13534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SpinEvent",kwnames,&obj0,&obj1)) goto fail;
13535     if (obj0) {
13536         {
13537             arg1 = (wxEventType)(SWIG_As_int(obj0));
13538             if (SWIG_arg_fail(1)) SWIG_fail;
13539         }
13540     }
13541     if (obj1) {
13542         {
13543             arg2 = (int)(SWIG_As_int(obj1));
13544             if (SWIG_arg_fail(2)) SWIG_fail;
13545         }
13546     }
13547     {
13548         PyThreadState* __tstate = wxPyBeginAllowThreads();
13549         result = (wxSpinEvent *)new wxSpinEvent(arg1,arg2);
13550
13551         wxPyEndAllowThreads(__tstate);
13552         if (PyErr_Occurred()) SWIG_fail;
13553     }
13554     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinEvent, 1);
13555     return resultobj;
13556     fail:
13557     return NULL;
13558 }
13559
13560
13561 static PyObject *_wrap_SpinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13562     PyObject *resultobj;
13563     wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
13564     int result;
13565     PyObject * obj0 = 0 ;
13566     char *kwnames[] = {
13567         (char *) "self", NULL
13568     };
13569
13570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinEvent_GetPosition",kwnames,&obj0)) goto fail;
13571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinEvent, SWIG_POINTER_EXCEPTION | 0);
13572     if (SWIG_arg_fail(1)) SWIG_fail;
13573     {
13574         PyThreadState* __tstate = wxPyBeginAllowThreads();
13575         result = (int)((wxSpinEvent const *)arg1)->GetPosition();
13576
13577         wxPyEndAllowThreads(__tstate);
13578         if (PyErr_Occurred()) SWIG_fail;
13579     }
13580     {
13581         resultobj = SWIG_From_int((int)(result));
13582     }
13583     return resultobj;
13584     fail:
13585     return NULL;
13586 }
13587
13588
13589 static PyObject *_wrap_SpinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13590     PyObject *resultobj;
13591     wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
13592     int arg2 ;
13593     PyObject * obj0 = 0 ;
13594     PyObject * obj1 = 0 ;
13595     char *kwnames[] = {
13596         (char *) "self",(char *) "pos", NULL
13597     };
13598
13599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinEvent, SWIG_POINTER_EXCEPTION | 0);
13601     if (SWIG_arg_fail(1)) SWIG_fail;
13602     {
13603         arg2 = (int)(SWIG_As_int(obj1));
13604         if (SWIG_arg_fail(2)) SWIG_fail;
13605     }
13606     {
13607         PyThreadState* __tstate = wxPyBeginAllowThreads();
13608         (arg1)->SetPosition(arg2);
13609
13610         wxPyEndAllowThreads(__tstate);
13611         if (PyErr_Occurred()) SWIG_fail;
13612     }
13613     Py_INCREF(Py_None); resultobj = Py_None;
13614     return resultobj;
13615     fail:
13616     return NULL;
13617 }
13618
13619
13620 static PyObject * SpinEvent_swigregister(PyObject *, PyObject *args) {
13621     PyObject *obj;
13622     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13623     SWIG_TypeClientData(SWIGTYPE_p_wxSpinEvent, obj);
13624     Py_INCREF(obj);
13625     return Py_BuildValue((char *)"");
13626 }
13627 static int _wrap_RadioBoxNameStr_set(PyObject *) {
13628     PyErr_SetString(PyExc_TypeError,"Variable RadioBoxNameStr is read-only.");
13629     return 1;
13630 }
13631
13632
13633 static PyObject *_wrap_RadioBoxNameStr_get(void) {
13634     PyObject *pyobj;
13635
13636     {
13637 #if wxUSE_UNICODE
13638         pyobj = PyUnicode_FromWideChar((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
13639 #else
13640         pyobj = PyString_FromStringAndSize((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
13641 #endif
13642     }
13643     return pyobj;
13644 }
13645
13646
13647 static int _wrap_RadioButtonNameStr_set(PyObject *) {
13648     PyErr_SetString(PyExc_TypeError,"Variable RadioButtonNameStr is read-only.");
13649     return 1;
13650 }
13651
13652
13653 static PyObject *_wrap_RadioButtonNameStr_get(void) {
13654     PyObject *pyobj;
13655
13656     {
13657 #if wxUSE_UNICODE
13658         pyobj = PyUnicode_FromWideChar((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
13659 #else
13660         pyobj = PyString_FromStringAndSize((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
13661 #endif
13662     }
13663     return pyobj;
13664 }
13665
13666
13667 static PyObject *_wrap_new_RadioBox(PyObject *, PyObject *args, PyObject *kwargs) {
13668     PyObject *resultobj;
13669     wxWindow *arg1 = (wxWindow *) 0 ;
13670     int arg2 = (int) -1 ;
13671     wxString const &arg3_defvalue = wxPyEmptyString ;
13672     wxString *arg3 = (wxString *) &arg3_defvalue ;
13673     wxPoint const &arg4_defvalue = wxDefaultPosition ;
13674     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
13675     wxSize const &arg5_defvalue = wxDefaultSize ;
13676     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
13677     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
13678     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
13679     int arg7 = (int) 0 ;
13680     long arg8 = (long) wxRA_HORIZONTAL ;
13681     wxValidator const &arg9_defvalue = wxDefaultValidator ;
13682     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
13683     wxString const &arg10_defvalue = wxPyRadioBoxNameStr ;
13684     wxString *arg10 = (wxString *) &arg10_defvalue ;
13685     wxRadioBox *result;
13686     bool temp3 = false ;
13687     wxPoint temp4 ;
13688     wxSize temp5 ;
13689     bool temp6 = false ;
13690     bool temp10 = false ;
13691     PyObject * obj0 = 0 ;
13692     PyObject * obj1 = 0 ;
13693     PyObject * obj2 = 0 ;
13694     PyObject * obj3 = 0 ;
13695     PyObject * obj4 = 0 ;
13696     PyObject * obj5 = 0 ;
13697     PyObject * obj6 = 0 ;
13698     PyObject * obj7 = 0 ;
13699     PyObject * obj8 = 0 ;
13700     PyObject * obj9 = 0 ;
13701     char *kwnames[] = {
13702         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL
13703     };
13704
13705     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_RadioBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
13706     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13707     if (SWIG_arg_fail(1)) SWIG_fail;
13708     if (obj1) {
13709         {
13710             arg2 = (int)(SWIG_As_int(obj1));
13711             if (SWIG_arg_fail(2)) SWIG_fail;
13712         }
13713     }
13714     if (obj2) {
13715         {
13716             arg3 = wxString_in_helper(obj2);
13717             if (arg3 == NULL) SWIG_fail;
13718             temp3 = true;
13719         }
13720     }
13721     if (obj3) {
13722         {
13723             arg4 = &temp4;
13724             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13725         }
13726     }
13727     if (obj4) {
13728         {
13729             arg5 = &temp5;
13730             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
13731         }
13732     }
13733     if (obj5) {
13734         {
13735             if (! PySequence_Check(obj5)) {
13736                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13737                 SWIG_fail;
13738             }
13739             arg6 = new wxArrayString;
13740             temp6 = true;
13741             int i, len=PySequence_Length(obj5);
13742             for (i=0; i<len; i++) {
13743                 PyObject* item = PySequence_GetItem(obj5, i);
13744 #if wxUSE_UNICODE
13745                 PyObject* str  = PyObject_Unicode(item);
13746 #else
13747                 PyObject* str  = PyObject_Str(item);
13748 #endif
13749                 if (PyErr_Occurred())  SWIG_fail;
13750                 arg6->Add(Py2wxString(str));
13751                 Py_DECREF(item);
13752                 Py_DECREF(str);
13753             }
13754         }
13755     }
13756     if (obj6) {
13757         {
13758             arg7 = (int)(SWIG_As_int(obj6));
13759             if (SWIG_arg_fail(7)) SWIG_fail;
13760         }
13761     }
13762     if (obj7) {
13763         {
13764             arg8 = (long)(SWIG_As_long(obj7));
13765             if (SWIG_arg_fail(8)) SWIG_fail;
13766         }
13767     }
13768     if (obj8) {
13769         {
13770             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
13771             if (SWIG_arg_fail(9)) SWIG_fail;
13772             if (arg9 == NULL) {
13773                 SWIG_null_ref("wxValidator");
13774             }
13775             if (SWIG_arg_fail(9)) SWIG_fail;
13776         }
13777     }
13778     if (obj9) {
13779         {
13780             arg10 = wxString_in_helper(obj9);
13781             if (arg10 == NULL) SWIG_fail;
13782             temp10 = true;
13783         }
13784     }
13785     {
13786         if (!wxPyCheckForApp()) SWIG_fail;
13787         PyThreadState* __tstate = wxPyBeginAllowThreads();
13788         result = (wxRadioBox *)new wxRadioBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
13789
13790         wxPyEndAllowThreads(__tstate);
13791         if (PyErr_Occurred()) SWIG_fail;
13792     }
13793     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioBox, 1);
13794     {
13795         if (temp3)
13796         delete arg3;
13797     }
13798     {
13799         if (temp6) delete arg6;
13800     }
13801     {
13802         if (temp10)
13803         delete arg10;
13804     }
13805     return resultobj;
13806     fail:
13807     {
13808         if (temp3)
13809         delete arg3;
13810     }
13811     {
13812         if (temp6) delete arg6;
13813     }
13814     {
13815         if (temp10)
13816         delete arg10;
13817     }
13818     return NULL;
13819 }
13820
13821
13822 static PyObject *_wrap_new_PreRadioBox(PyObject *, PyObject *args, PyObject *kwargs) {
13823     PyObject *resultobj;
13824     wxRadioBox *result;
13825     char *kwnames[] = {
13826         NULL
13827     };
13828
13829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreRadioBox",kwnames)) goto fail;
13830     {
13831         if (!wxPyCheckForApp()) SWIG_fail;
13832         PyThreadState* __tstate = wxPyBeginAllowThreads();
13833         result = (wxRadioBox *)new wxRadioBox();
13834
13835         wxPyEndAllowThreads(__tstate);
13836         if (PyErr_Occurred()) SWIG_fail;
13837     }
13838     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioBox, 1);
13839     return resultobj;
13840     fail:
13841     return NULL;
13842 }
13843
13844
13845 static PyObject *_wrap_RadioBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13846     PyObject *resultobj;
13847     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
13848     wxWindow *arg2 = (wxWindow *) 0 ;
13849     int arg3 = (int) -1 ;
13850     wxString const &arg4_defvalue = wxPyEmptyString ;
13851     wxString *arg4 = (wxString *) &arg4_defvalue ;
13852     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13853     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13854     wxSize const &arg6_defvalue = wxDefaultSize ;
13855     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13856     wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
13857     wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
13858     int arg8 = (int) 0 ;
13859     long arg9 = (long) wxRA_HORIZONTAL ;
13860     wxValidator const &arg10_defvalue = wxDefaultValidator ;
13861     wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
13862     wxString const &arg11_defvalue = wxPyRadioBoxNameStr ;
13863     wxString *arg11 = (wxString *) &arg11_defvalue ;
13864     bool result;
13865     bool temp4 = false ;
13866     wxPoint temp5 ;
13867     wxSize temp6 ;
13868     bool temp7 = false ;
13869     bool temp11 = false ;
13870     PyObject * obj0 = 0 ;
13871     PyObject * obj1 = 0 ;
13872     PyObject * obj2 = 0 ;
13873     PyObject * obj3 = 0 ;
13874     PyObject * obj4 = 0 ;
13875     PyObject * obj5 = 0 ;
13876     PyObject * obj6 = 0 ;
13877     PyObject * obj7 = 0 ;
13878     PyObject * obj8 = 0 ;
13879     PyObject * obj9 = 0 ;
13880     PyObject * obj10 = 0 ;
13881     char *kwnames[] = {
13882         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL
13883     };
13884
13885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:RadioBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
13886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
13887     if (SWIG_arg_fail(1)) SWIG_fail;
13888     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13889     if (SWIG_arg_fail(2)) SWIG_fail;
13890     if (obj2) {
13891         {
13892             arg3 = (int)(SWIG_As_int(obj2));
13893             if (SWIG_arg_fail(3)) SWIG_fail;
13894         }
13895     }
13896     if (obj3) {
13897         {
13898             arg4 = wxString_in_helper(obj3);
13899             if (arg4 == NULL) SWIG_fail;
13900             temp4 = true;
13901         }
13902     }
13903     if (obj4) {
13904         {
13905             arg5 = &temp5;
13906             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13907         }
13908     }
13909     if (obj5) {
13910         {
13911             arg6 = &temp6;
13912             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13913         }
13914     }
13915     if (obj6) {
13916         {
13917             if (! PySequence_Check(obj6)) {
13918                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13919                 SWIG_fail;
13920             }
13921             arg7 = new wxArrayString;
13922             temp7 = true;
13923             int i, len=PySequence_Length(obj6);
13924             for (i=0; i<len; i++) {
13925                 PyObject* item = PySequence_GetItem(obj6, i);
13926 #if wxUSE_UNICODE
13927                 PyObject* str  = PyObject_Unicode(item);
13928 #else
13929                 PyObject* str  = PyObject_Str(item);
13930 #endif
13931                 if (PyErr_Occurred())  SWIG_fail;
13932                 arg7->Add(Py2wxString(str));
13933                 Py_DECREF(item);
13934                 Py_DECREF(str);
13935             }
13936         }
13937     }
13938     if (obj7) {
13939         {
13940             arg8 = (int)(SWIG_As_int(obj7));
13941             if (SWIG_arg_fail(8)) SWIG_fail;
13942         }
13943     }
13944     if (obj8) {
13945         {
13946             arg9 = (long)(SWIG_As_long(obj8));
13947             if (SWIG_arg_fail(9)) SWIG_fail;
13948         }
13949     }
13950     if (obj9) {
13951         {
13952             SWIG_Python_ConvertPtr(obj9, (void **)&arg10, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
13953             if (SWIG_arg_fail(10)) SWIG_fail;
13954             if (arg10 == NULL) {
13955                 SWIG_null_ref("wxValidator");
13956             }
13957             if (SWIG_arg_fail(10)) SWIG_fail;
13958         }
13959     }
13960     if (obj10) {
13961         {
13962             arg11 = wxString_in_helper(obj10);
13963             if (arg11 == NULL) SWIG_fail;
13964             temp11 = true;
13965         }
13966     }
13967     {
13968         PyThreadState* __tstate = wxPyBeginAllowThreads();
13969         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
13970
13971         wxPyEndAllowThreads(__tstate);
13972         if (PyErr_Occurred()) SWIG_fail;
13973     }
13974     {
13975         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13976     }
13977     {
13978         if (temp4)
13979         delete arg4;
13980     }
13981     {
13982         if (temp7) delete arg7;
13983     }
13984     {
13985         if (temp11)
13986         delete arg11;
13987     }
13988     return resultobj;
13989     fail:
13990     {
13991         if (temp4)
13992         delete arg4;
13993     }
13994     {
13995         if (temp7) delete arg7;
13996     }
13997     {
13998         if (temp11)
13999         delete arg11;
14000     }
14001     return NULL;
14002 }
14003
14004
14005 static PyObject *_wrap_RadioBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14006     PyObject *resultobj;
14007     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14008     int arg2 ;
14009     PyObject * obj0 = 0 ;
14010     PyObject * obj1 = 0 ;
14011     char *kwnames[] = {
14012         (char *) "self",(char *) "n", NULL
14013     };
14014
14015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14017     if (SWIG_arg_fail(1)) SWIG_fail;
14018     {
14019         arg2 = (int)(SWIG_As_int(obj1));
14020         if (SWIG_arg_fail(2)) SWIG_fail;
14021     }
14022     {
14023         PyThreadState* __tstate = wxPyBeginAllowThreads();
14024         (arg1)->SetSelection(arg2);
14025
14026         wxPyEndAllowThreads(__tstate);
14027         if (PyErr_Occurred()) SWIG_fail;
14028     }
14029     Py_INCREF(Py_None); resultobj = Py_None;
14030     return resultobj;
14031     fail:
14032     return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_RadioBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14037     PyObject *resultobj;
14038     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14039     int result;
14040     PyObject * obj0 = 0 ;
14041     char *kwnames[] = {
14042         (char *) "self", NULL
14043     };
14044
14045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetSelection",kwnames,&obj0)) goto fail;
14046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14047     if (SWIG_arg_fail(1)) SWIG_fail;
14048     {
14049         PyThreadState* __tstate = wxPyBeginAllowThreads();
14050         result = (int)((wxRadioBox const *)arg1)->GetSelection();
14051
14052         wxPyEndAllowThreads(__tstate);
14053         if (PyErr_Occurred()) SWIG_fail;
14054     }
14055     {
14056         resultobj = SWIG_From_int((int)(result));
14057     }
14058     return resultobj;
14059     fail:
14060     return NULL;
14061 }
14062
14063
14064 static PyObject *_wrap_RadioBox_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14065     PyObject *resultobj;
14066     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14067     wxString result;
14068     PyObject * obj0 = 0 ;
14069     char *kwnames[] = {
14070         (char *) "self", NULL
14071     };
14072
14073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetStringSelection",kwnames,&obj0)) goto fail;
14074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14075     if (SWIG_arg_fail(1)) SWIG_fail;
14076     {
14077         PyThreadState* __tstate = wxPyBeginAllowThreads();
14078         result = ((wxRadioBox const *)arg1)->GetStringSelection();
14079
14080         wxPyEndAllowThreads(__tstate);
14081         if (PyErr_Occurred()) SWIG_fail;
14082     }
14083     {
14084 #if wxUSE_UNICODE
14085         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14086 #else
14087         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14088 #endif
14089     }
14090     return resultobj;
14091     fail:
14092     return NULL;
14093 }
14094
14095
14096 static PyObject *_wrap_RadioBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14097     PyObject *resultobj;
14098     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14099     wxString *arg2 = 0 ;
14100     bool result;
14101     bool temp2 = false ;
14102     PyObject * obj0 = 0 ;
14103     PyObject * obj1 = 0 ;
14104     char *kwnames[] = {
14105         (char *) "self",(char *) "s", NULL
14106     };
14107
14108     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
14109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14110     if (SWIG_arg_fail(1)) SWIG_fail;
14111     {
14112         arg2 = wxString_in_helper(obj1);
14113         if (arg2 == NULL) SWIG_fail;
14114         temp2 = true;
14115     }
14116     {
14117         PyThreadState* __tstate = wxPyBeginAllowThreads();
14118         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
14119
14120         wxPyEndAllowThreads(__tstate);
14121         if (PyErr_Occurred()) SWIG_fail;
14122     }
14123     {
14124         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14125     }
14126     {
14127         if (temp2)
14128         delete arg2;
14129     }
14130     return resultobj;
14131     fail:
14132     {
14133         if (temp2)
14134         delete arg2;
14135     }
14136     return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_RadioBox_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
14141     PyObject *resultobj;
14142     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14143     int result;
14144     PyObject * obj0 = 0 ;
14145     char *kwnames[] = {
14146         (char *) "self", NULL
14147     };
14148
14149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetCount",kwnames,&obj0)) goto fail;
14150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14151     if (SWIG_arg_fail(1)) SWIG_fail;
14152     {
14153         PyThreadState* __tstate = wxPyBeginAllowThreads();
14154         result = (int)((wxRadioBox const *)arg1)->GetCount();
14155
14156         wxPyEndAllowThreads(__tstate);
14157         if (PyErr_Occurred()) SWIG_fail;
14158     }
14159     {
14160         resultobj = SWIG_From_int((int)(result));
14161     }
14162     return resultobj;
14163     fail:
14164     return NULL;
14165 }
14166
14167
14168 static PyObject *_wrap_RadioBox_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
14169     PyObject *resultobj;
14170     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14171     wxString *arg2 = 0 ;
14172     int result;
14173     bool temp2 = false ;
14174     PyObject * obj0 = 0 ;
14175     PyObject * obj1 = 0 ;
14176     char *kwnames[] = {
14177         (char *) "self",(char *) "s", NULL
14178     };
14179
14180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_FindString",kwnames,&obj0,&obj1)) goto fail;
14181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14182     if (SWIG_arg_fail(1)) SWIG_fail;
14183     {
14184         arg2 = wxString_in_helper(obj1);
14185         if (arg2 == NULL) SWIG_fail;
14186         temp2 = true;
14187     }
14188     {
14189         PyThreadState* __tstate = wxPyBeginAllowThreads();
14190         result = (int)((wxRadioBox const *)arg1)->FindString((wxString const &)*arg2);
14191
14192         wxPyEndAllowThreads(__tstate);
14193         if (PyErr_Occurred()) SWIG_fail;
14194     }
14195     {
14196         resultobj = SWIG_From_int((int)(result));
14197     }
14198     {
14199         if (temp2)
14200         delete arg2;
14201     }
14202     return resultobj;
14203     fail:
14204     {
14205         if (temp2)
14206         delete arg2;
14207     }
14208     return NULL;
14209 }
14210
14211
14212 static PyObject *_wrap_RadioBox_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14213     PyObject *resultobj;
14214     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14215     int arg2 ;
14216     wxString result;
14217     PyObject * obj0 = 0 ;
14218     PyObject * obj1 = 0 ;
14219     char *kwnames[] = {
14220         (char *) "self",(char *) "n", NULL
14221     };
14222
14223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_GetString",kwnames,&obj0,&obj1)) goto fail;
14224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14225     if (SWIG_arg_fail(1)) SWIG_fail;
14226     {
14227         arg2 = (int)(SWIG_As_int(obj1));
14228         if (SWIG_arg_fail(2)) SWIG_fail;
14229     }
14230     {
14231         PyThreadState* __tstate = wxPyBeginAllowThreads();
14232         result = ((wxRadioBox const *)arg1)->GetString(arg2);
14233
14234         wxPyEndAllowThreads(__tstate);
14235         if (PyErr_Occurred()) SWIG_fail;
14236     }
14237     {
14238 #if wxUSE_UNICODE
14239         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14240 #else
14241         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14242 #endif
14243     }
14244     return resultobj;
14245     fail:
14246     return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_RadioBox_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14251     PyObject *resultobj;
14252     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14253     int arg2 ;
14254     wxString *arg3 = 0 ;
14255     bool temp3 = false ;
14256     PyObject * obj0 = 0 ;
14257     PyObject * obj1 = 0 ;
14258     PyObject * obj2 = 0 ;
14259     char *kwnames[] = {
14260         (char *) "self",(char *) "n",(char *) "label", NULL
14261     };
14262
14263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RadioBox_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
14264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14265     if (SWIG_arg_fail(1)) SWIG_fail;
14266     {
14267         arg2 = (int)(SWIG_As_int(obj1));
14268         if (SWIG_arg_fail(2)) SWIG_fail;
14269     }
14270     {
14271         arg3 = wxString_in_helper(obj2);
14272         if (arg3 == NULL) SWIG_fail;
14273         temp3 = true;
14274     }
14275     {
14276         PyThreadState* __tstate = wxPyBeginAllowThreads();
14277         (arg1)->SetString(arg2,(wxString const &)*arg3);
14278
14279         wxPyEndAllowThreads(__tstate);
14280         if (PyErr_Occurred()) SWIG_fail;
14281     }
14282     Py_INCREF(Py_None); resultobj = Py_None;
14283     {
14284         if (temp3)
14285         delete arg3;
14286     }
14287     return resultobj;
14288     fail:
14289     {
14290         if (temp3)
14291         delete arg3;
14292     }
14293     return NULL;
14294 }
14295
14296
14297 static PyObject *_wrap_RadioBox_EnableItem(PyObject *, PyObject *args, PyObject *kwargs) {
14298     PyObject *resultobj;
14299     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14300     int arg2 ;
14301     bool arg3 = (bool) true ;
14302     PyObject * obj0 = 0 ;
14303     PyObject * obj1 = 0 ;
14304     PyObject * obj2 = 0 ;
14305     char *kwnames[] = {
14306         (char *) "self",(char *) "n",(char *) "enable", NULL
14307     };
14308
14309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_EnableItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
14310     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14311     if (SWIG_arg_fail(1)) SWIG_fail;
14312     {
14313         arg2 = (int)(SWIG_As_int(obj1));
14314         if (SWIG_arg_fail(2)) SWIG_fail;
14315     }
14316     if (obj2) {
14317         {
14318             arg3 = (bool)(SWIG_As_bool(obj2));
14319             if (SWIG_arg_fail(3)) SWIG_fail;
14320         }
14321     }
14322     {
14323         PyThreadState* __tstate = wxPyBeginAllowThreads();
14324         (arg1)->Enable(arg2,arg3);
14325
14326         wxPyEndAllowThreads(__tstate);
14327         if (PyErr_Occurred()) SWIG_fail;
14328     }
14329     Py_INCREF(Py_None); resultobj = Py_None;
14330     return resultobj;
14331     fail:
14332     return NULL;
14333 }
14334
14335
14336 static PyObject *_wrap_RadioBox_ShowItem(PyObject *, PyObject *args, PyObject *kwargs) {
14337     PyObject *resultobj;
14338     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14339     int arg2 ;
14340     bool arg3 = (bool) true ;
14341     PyObject * obj0 = 0 ;
14342     PyObject * obj1 = 0 ;
14343     PyObject * obj2 = 0 ;
14344     char *kwnames[] = {
14345         (char *) "self",(char *) "n",(char *) "show", NULL
14346     };
14347
14348     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_ShowItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
14349     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14350     if (SWIG_arg_fail(1)) SWIG_fail;
14351     {
14352         arg2 = (int)(SWIG_As_int(obj1));
14353         if (SWIG_arg_fail(2)) SWIG_fail;
14354     }
14355     if (obj2) {
14356         {
14357             arg3 = (bool)(SWIG_As_bool(obj2));
14358             if (SWIG_arg_fail(3)) SWIG_fail;
14359         }
14360     }
14361     {
14362         PyThreadState* __tstate = wxPyBeginAllowThreads();
14363         (arg1)->Show(arg2,arg3);
14364
14365         wxPyEndAllowThreads(__tstate);
14366         if (PyErr_Occurred()) SWIG_fail;
14367     }
14368     Py_INCREF(Py_None); resultobj = Py_None;
14369     return resultobj;
14370     fail:
14371     return NULL;
14372 }
14373
14374
14375 static PyObject *_wrap_RadioBox_GetColumnCount(PyObject *, PyObject *args, PyObject *kwargs) {
14376     PyObject *resultobj;
14377     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14378     int result;
14379     PyObject * obj0 = 0 ;
14380     char *kwnames[] = {
14381         (char *) "self", NULL
14382     };
14383
14384     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetColumnCount",kwnames,&obj0)) goto fail;
14385     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14386     if (SWIG_arg_fail(1)) SWIG_fail;
14387     {
14388         PyThreadState* __tstate = wxPyBeginAllowThreads();
14389         result = (int)((wxRadioBox const *)arg1)->GetColumnCount();
14390
14391         wxPyEndAllowThreads(__tstate);
14392         if (PyErr_Occurred()) SWIG_fail;
14393     }
14394     {
14395         resultobj = SWIG_From_int((int)(result));
14396     }
14397     return resultobj;
14398     fail:
14399     return NULL;
14400 }
14401
14402
14403 static PyObject *_wrap_RadioBox_GetRowCount(PyObject *, PyObject *args, PyObject *kwargs) {
14404     PyObject *resultobj;
14405     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14406     int result;
14407     PyObject * obj0 = 0 ;
14408     char *kwnames[] = {
14409         (char *) "self", NULL
14410     };
14411
14412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetRowCount",kwnames,&obj0)) goto fail;
14413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14414     if (SWIG_arg_fail(1)) SWIG_fail;
14415     {
14416         PyThreadState* __tstate = wxPyBeginAllowThreads();
14417         result = (int)((wxRadioBox const *)arg1)->GetRowCount();
14418
14419         wxPyEndAllowThreads(__tstate);
14420         if (PyErr_Occurred()) SWIG_fail;
14421     }
14422     {
14423         resultobj = SWIG_From_int((int)(result));
14424     }
14425     return resultobj;
14426     fail:
14427     return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_RadioBox_GetNextItem(PyObject *, PyObject *args, PyObject *kwargs) {
14432     PyObject *resultobj;
14433     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14434     int arg2 ;
14435     wxDirection arg3 ;
14436     long arg4 ;
14437     int result;
14438     PyObject * obj0 = 0 ;
14439     PyObject * obj1 = 0 ;
14440     PyObject * obj2 = 0 ;
14441     PyObject * obj3 = 0 ;
14442     char *kwnames[] = {
14443         (char *) "self",(char *) "item",(char *) "dir",(char *) "style", NULL
14444     };
14445
14446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RadioBox_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14448     if (SWIG_arg_fail(1)) SWIG_fail;
14449     {
14450         arg2 = (int)(SWIG_As_int(obj1));
14451         if (SWIG_arg_fail(2)) SWIG_fail;
14452     }
14453     {
14454         arg3 = (wxDirection)(SWIG_As_int(obj2));
14455         if (SWIG_arg_fail(3)) SWIG_fail;
14456     }
14457     {
14458         arg4 = (long)(SWIG_As_long(obj3));
14459         if (SWIG_arg_fail(4)) SWIG_fail;
14460     }
14461     {
14462         PyThreadState* __tstate = wxPyBeginAllowThreads();
14463         result = (int)((wxRadioBox const *)arg1)->GetNextItem(arg2,(wxDirection )arg3,arg4);
14464
14465         wxPyEndAllowThreads(__tstate);
14466         if (PyErr_Occurred()) SWIG_fail;
14467     }
14468     {
14469         resultobj = SWIG_From_int((int)(result));
14470     }
14471     return resultobj;
14472     fail:
14473     return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_RadioBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
14478     PyObject *resultobj;
14479     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
14480     wxVisualAttributes result;
14481     PyObject * obj0 = 0 ;
14482     char *kwnames[] = {
14483         (char *) "variant", NULL
14484     };
14485
14486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
14487     if (obj0) {
14488         {
14489             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
14490             if (SWIG_arg_fail(1)) SWIG_fail;
14491         }
14492     }
14493     {
14494         if (!wxPyCheckForApp()) SWIG_fail;
14495         PyThreadState* __tstate = wxPyBeginAllowThreads();
14496         result = wxRadioBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
14497
14498         wxPyEndAllowThreads(__tstate);
14499         if (PyErr_Occurred()) SWIG_fail;
14500     }
14501     {
14502         wxVisualAttributes * resultptr;
14503         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
14504         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
14505     }
14506     return resultobj;
14507     fail:
14508     return NULL;
14509 }
14510
14511
14512 static PyObject * RadioBox_swigregister(PyObject *, PyObject *args) {
14513     PyObject *obj;
14514     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14515     SWIG_TypeClientData(SWIGTYPE_p_wxRadioBox, obj);
14516     Py_INCREF(obj);
14517     return Py_BuildValue((char *)"");
14518 }
14519 static PyObject *_wrap_new_RadioButton(PyObject *, PyObject *args, PyObject *kwargs) {
14520     PyObject *resultobj;
14521     wxWindow *arg1 = (wxWindow *) 0 ;
14522     int arg2 = (int) -1 ;
14523     wxString const &arg3_defvalue = wxPyEmptyString ;
14524     wxString *arg3 = (wxString *) &arg3_defvalue ;
14525     wxPoint const &arg4_defvalue = wxDefaultPosition ;
14526     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
14527     wxSize const &arg5_defvalue = wxDefaultSize ;
14528     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
14529     long arg6 = (long) 0 ;
14530     wxValidator const &arg7_defvalue = wxDefaultValidator ;
14531     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
14532     wxString const &arg8_defvalue = wxPyRadioButtonNameStr ;
14533     wxString *arg8 = (wxString *) &arg8_defvalue ;
14534     wxRadioButton *result;
14535     bool temp3 = false ;
14536     wxPoint temp4 ;
14537     wxSize temp5 ;
14538     bool temp8 = false ;
14539     PyObject * obj0 = 0 ;
14540     PyObject * obj1 = 0 ;
14541     PyObject * obj2 = 0 ;
14542     PyObject * obj3 = 0 ;
14543     PyObject * obj4 = 0 ;
14544     PyObject * obj5 = 0 ;
14545     PyObject * obj6 = 0 ;
14546     PyObject * obj7 = 0 ;
14547     char *kwnames[] = {
14548         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14549     };
14550
14551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_RadioButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14553     if (SWIG_arg_fail(1)) SWIG_fail;
14554     if (obj1) {
14555         {
14556             arg2 = (int)(SWIG_As_int(obj1));
14557             if (SWIG_arg_fail(2)) SWIG_fail;
14558         }
14559     }
14560     if (obj2) {
14561         {
14562             arg3 = wxString_in_helper(obj2);
14563             if (arg3 == NULL) SWIG_fail;
14564             temp3 = true;
14565         }
14566     }
14567     if (obj3) {
14568         {
14569             arg4 = &temp4;
14570             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
14571         }
14572     }
14573     if (obj4) {
14574         {
14575             arg5 = &temp5;
14576             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
14577         }
14578     }
14579     if (obj5) {
14580         {
14581             arg6 = (long)(SWIG_As_long(obj5));
14582             if (SWIG_arg_fail(6)) SWIG_fail;
14583         }
14584     }
14585     if (obj6) {
14586         {
14587             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14588             if (SWIG_arg_fail(7)) SWIG_fail;
14589             if (arg7 == NULL) {
14590                 SWIG_null_ref("wxValidator");
14591             }
14592             if (SWIG_arg_fail(7)) SWIG_fail;
14593         }
14594     }
14595     if (obj7) {
14596         {
14597             arg8 = wxString_in_helper(obj7);
14598             if (arg8 == NULL) SWIG_fail;
14599             temp8 = true;
14600         }
14601     }
14602     {
14603         if (!wxPyCheckForApp()) SWIG_fail;
14604         PyThreadState* __tstate = wxPyBeginAllowThreads();
14605         result = (wxRadioButton *)new wxRadioButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
14606
14607         wxPyEndAllowThreads(__tstate);
14608         if (PyErr_Occurred()) SWIG_fail;
14609     }
14610     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioButton, 1);
14611     {
14612         if (temp3)
14613         delete arg3;
14614     }
14615     {
14616         if (temp8)
14617         delete arg8;
14618     }
14619     return resultobj;
14620     fail:
14621     {
14622         if (temp3)
14623         delete arg3;
14624     }
14625     {
14626         if (temp8)
14627         delete arg8;
14628     }
14629     return NULL;
14630 }
14631
14632
14633 static PyObject *_wrap_new_PreRadioButton(PyObject *, PyObject *args, PyObject *kwargs) {
14634     PyObject *resultobj;
14635     wxRadioButton *result;
14636     char *kwnames[] = {
14637         NULL
14638     };
14639
14640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreRadioButton",kwnames)) goto fail;
14641     {
14642         if (!wxPyCheckForApp()) SWIG_fail;
14643         PyThreadState* __tstate = wxPyBeginAllowThreads();
14644         result = (wxRadioButton *)new wxRadioButton();
14645
14646         wxPyEndAllowThreads(__tstate);
14647         if (PyErr_Occurred()) SWIG_fail;
14648     }
14649     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioButton, 1);
14650     return resultobj;
14651     fail:
14652     return NULL;
14653 }
14654
14655
14656 static PyObject *_wrap_RadioButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14657     PyObject *resultobj;
14658     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14659     wxWindow *arg2 = (wxWindow *) 0 ;
14660     int arg3 = (int) -1 ;
14661     wxString const &arg4_defvalue = wxPyEmptyString ;
14662     wxString *arg4 = (wxString *) &arg4_defvalue ;
14663     wxPoint const &arg5_defvalue = wxDefaultPosition ;
14664     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
14665     wxSize const &arg6_defvalue = wxDefaultSize ;
14666     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
14667     long arg7 = (long) 0 ;
14668     wxValidator const &arg8_defvalue = wxDefaultValidator ;
14669     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
14670     wxString const &arg9_defvalue = wxPyRadioButtonNameStr ;
14671     wxString *arg9 = (wxString *) &arg9_defvalue ;
14672     bool result;
14673     bool temp4 = false ;
14674     wxPoint temp5 ;
14675     wxSize temp6 ;
14676     bool temp9 = false ;
14677     PyObject * obj0 = 0 ;
14678     PyObject * obj1 = 0 ;
14679     PyObject * obj2 = 0 ;
14680     PyObject * obj3 = 0 ;
14681     PyObject * obj4 = 0 ;
14682     PyObject * obj5 = 0 ;
14683     PyObject * obj6 = 0 ;
14684     PyObject * obj7 = 0 ;
14685     PyObject * obj8 = 0 ;
14686     char *kwnames[] = {
14687         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14688     };
14689
14690     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:RadioButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
14691     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14692     if (SWIG_arg_fail(1)) SWIG_fail;
14693     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14694     if (SWIG_arg_fail(2)) SWIG_fail;
14695     if (obj2) {
14696         {
14697             arg3 = (int)(SWIG_As_int(obj2));
14698             if (SWIG_arg_fail(3)) SWIG_fail;
14699         }
14700     }
14701     if (obj3) {
14702         {
14703             arg4 = wxString_in_helper(obj3);
14704             if (arg4 == NULL) SWIG_fail;
14705             temp4 = true;
14706         }
14707     }
14708     if (obj4) {
14709         {
14710             arg5 = &temp5;
14711             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14712         }
14713     }
14714     if (obj5) {
14715         {
14716             arg6 = &temp6;
14717             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
14718         }
14719     }
14720     if (obj6) {
14721         {
14722             arg7 = (long)(SWIG_As_long(obj6));
14723             if (SWIG_arg_fail(7)) SWIG_fail;
14724         }
14725     }
14726     if (obj7) {
14727         {
14728             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14729             if (SWIG_arg_fail(8)) SWIG_fail;
14730             if (arg8 == NULL) {
14731                 SWIG_null_ref("wxValidator");
14732             }
14733             if (SWIG_arg_fail(8)) SWIG_fail;
14734         }
14735     }
14736     if (obj8) {
14737         {
14738             arg9 = wxString_in_helper(obj8);
14739             if (arg9 == NULL) SWIG_fail;
14740             temp9 = true;
14741         }
14742     }
14743     {
14744         PyThreadState* __tstate = wxPyBeginAllowThreads();
14745         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
14746
14747         wxPyEndAllowThreads(__tstate);
14748         if (PyErr_Occurred()) SWIG_fail;
14749     }
14750     {
14751         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752     }
14753     {
14754         if (temp4)
14755         delete arg4;
14756     }
14757     {
14758         if (temp9)
14759         delete arg9;
14760     }
14761     return resultobj;
14762     fail:
14763     {
14764         if (temp4)
14765         delete arg4;
14766     }
14767     {
14768         if (temp9)
14769         delete arg9;
14770     }
14771     return NULL;
14772 }
14773
14774
14775 static PyObject *_wrap_RadioButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
14776     PyObject *resultobj;
14777     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14778     bool result;
14779     PyObject * obj0 = 0 ;
14780     char *kwnames[] = {
14781         (char *) "self", NULL
14782     };
14783
14784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioButton_GetValue",kwnames,&obj0)) goto fail;
14785     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14786     if (SWIG_arg_fail(1)) SWIG_fail;
14787     {
14788         PyThreadState* __tstate = wxPyBeginAllowThreads();
14789         result = (bool)(arg1)->GetValue();
14790
14791         wxPyEndAllowThreads(__tstate);
14792         if (PyErr_Occurred()) SWIG_fail;
14793     }
14794     {
14795         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14796     }
14797     return resultobj;
14798     fail:
14799     return NULL;
14800 }
14801
14802
14803 static PyObject *_wrap_RadioButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
14804     PyObject *resultobj;
14805     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14806     bool arg2 ;
14807     PyObject * obj0 = 0 ;
14808     PyObject * obj1 = 0 ;
14809     char *kwnames[] = {
14810         (char *) "self",(char *) "value", NULL
14811     };
14812
14813     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
14814     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14815     if (SWIG_arg_fail(1)) SWIG_fail;
14816     {
14817         arg2 = (bool)(SWIG_As_bool(obj1));
14818         if (SWIG_arg_fail(2)) SWIG_fail;
14819     }
14820     {
14821         PyThreadState* __tstate = wxPyBeginAllowThreads();
14822         (arg1)->SetValue(arg2);
14823
14824         wxPyEndAllowThreads(__tstate);
14825         if (PyErr_Occurred()) SWIG_fail;
14826     }
14827     Py_INCREF(Py_None); resultobj = Py_None;
14828     return resultobj;
14829     fail:
14830     return NULL;
14831 }
14832
14833
14834 static PyObject *_wrap_RadioButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
14835     PyObject *resultobj;
14836     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
14837     wxVisualAttributes result;
14838     PyObject * obj0 = 0 ;
14839     char *kwnames[] = {
14840         (char *) "variant", NULL
14841     };
14842
14843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
14844     if (obj0) {
14845         {
14846             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
14847             if (SWIG_arg_fail(1)) SWIG_fail;
14848         }
14849     }
14850     {
14851         if (!wxPyCheckForApp()) SWIG_fail;
14852         PyThreadState* __tstate = wxPyBeginAllowThreads();
14853         result = wxRadioButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
14854
14855         wxPyEndAllowThreads(__tstate);
14856         if (PyErr_Occurred()) SWIG_fail;
14857     }
14858     {
14859         wxVisualAttributes * resultptr;
14860         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
14861         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
14862     }
14863     return resultobj;
14864     fail:
14865     return NULL;
14866 }
14867
14868
14869 static PyObject * RadioButton_swigregister(PyObject *, PyObject *args) {
14870     PyObject *obj;
14871     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14872     SWIG_TypeClientData(SWIGTYPE_p_wxRadioButton, obj);
14873     Py_INCREF(obj);
14874     return Py_BuildValue((char *)"");
14875 }
14876 static int _wrap_SliderNameStr_set(PyObject *) {
14877     PyErr_SetString(PyExc_TypeError,"Variable SliderNameStr is read-only.");
14878     return 1;
14879 }
14880
14881
14882 static PyObject *_wrap_SliderNameStr_get(void) {
14883     PyObject *pyobj;
14884
14885     {
14886 #if wxUSE_UNICODE
14887         pyobj = PyUnicode_FromWideChar((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
14888 #else
14889         pyobj = PyString_FromStringAndSize((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
14890 #endif
14891     }
14892     return pyobj;
14893 }
14894
14895
14896 static PyObject *_wrap_new_Slider(PyObject *, PyObject *args, PyObject *kwargs) {
14897     PyObject *resultobj;
14898     wxWindow *arg1 = (wxWindow *) 0 ;
14899     int arg2 = (int) -1 ;
14900     int arg3 = (int) 0 ;
14901     int arg4 = (int) 0 ;
14902     int arg5 = (int) 100 ;
14903     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14904     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14905     wxSize const &arg7_defvalue = wxDefaultSize ;
14906     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
14907     long arg8 = (long) wxSL_HORIZONTAL ;
14908     wxValidator const &arg9_defvalue = wxDefaultValidator ;
14909     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
14910     wxString const &arg10_defvalue = wxPySliderNameStr ;
14911     wxString *arg10 = (wxString *) &arg10_defvalue ;
14912     wxSlider *result;
14913     wxPoint temp6 ;
14914     wxSize temp7 ;
14915     bool temp10 = false ;
14916     PyObject * obj0 = 0 ;
14917     PyObject * obj1 = 0 ;
14918     PyObject * obj2 = 0 ;
14919     PyObject * obj3 = 0 ;
14920     PyObject * obj4 = 0 ;
14921     PyObject * obj5 = 0 ;
14922     PyObject * obj6 = 0 ;
14923     PyObject * obj7 = 0 ;
14924     PyObject * obj8 = 0 ;
14925     PyObject * obj9 = 0 ;
14926     char *kwnames[] = {
14927         (char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14928     };
14929
14930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_Slider",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
14931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14932     if (SWIG_arg_fail(1)) SWIG_fail;
14933     if (obj1) {
14934         {
14935             arg2 = (int)(SWIG_As_int(obj1));
14936             if (SWIG_arg_fail(2)) SWIG_fail;
14937         }
14938     }
14939     if (obj2) {
14940         {
14941             arg3 = (int)(SWIG_As_int(obj2));
14942             if (SWIG_arg_fail(3)) SWIG_fail;
14943         }
14944     }
14945     if (obj3) {
14946         {
14947             arg4 = (int)(SWIG_As_int(obj3));
14948             if (SWIG_arg_fail(4)) SWIG_fail;
14949         }
14950     }
14951     if (obj4) {
14952         {
14953             arg5 = (int)(SWIG_As_int(obj4));
14954             if (SWIG_arg_fail(5)) SWIG_fail;
14955         }
14956     }
14957     if (obj5) {
14958         {
14959             arg6 = &temp6;
14960             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
14961         }
14962     }
14963     if (obj6) {
14964         {
14965             arg7 = &temp7;
14966             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
14967         }
14968     }
14969     if (obj7) {
14970         {
14971             arg8 = (long)(SWIG_As_long(obj7));
14972             if (SWIG_arg_fail(8)) SWIG_fail;
14973         }
14974     }
14975     if (obj8) {
14976         {
14977             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14978             if (SWIG_arg_fail(9)) SWIG_fail;
14979             if (arg9 == NULL) {
14980                 SWIG_null_ref("wxValidator");
14981             }
14982             if (SWIG_arg_fail(9)) SWIG_fail;
14983         }
14984     }
14985     if (obj9) {
14986         {
14987             arg10 = wxString_in_helper(obj9);
14988             if (arg10 == NULL) SWIG_fail;
14989             temp10 = true;
14990         }
14991     }
14992     {
14993         if (!wxPyCheckForApp()) SWIG_fail;
14994         PyThreadState* __tstate = wxPyBeginAllowThreads();
14995         result = (wxSlider *)new wxSlider(arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
14996
14997         wxPyEndAllowThreads(__tstate);
14998         if (PyErr_Occurred()) SWIG_fail;
14999     }
15000     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSlider, 1);
15001     {
15002         if (temp10)
15003         delete arg10;
15004     }
15005     return resultobj;
15006     fail:
15007     {
15008         if (temp10)
15009         delete arg10;
15010     }
15011     return NULL;
15012 }
15013
15014
15015 static PyObject *_wrap_new_PreSlider(PyObject *, PyObject *args, PyObject *kwargs) {
15016     PyObject *resultobj;
15017     wxSlider *result;
15018     char *kwnames[] = {
15019         NULL
15020     };
15021
15022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSlider",kwnames)) goto fail;
15023     {
15024         if (!wxPyCheckForApp()) SWIG_fail;
15025         PyThreadState* __tstate = wxPyBeginAllowThreads();
15026         result = (wxSlider *)new wxSlider();
15027
15028         wxPyEndAllowThreads(__tstate);
15029         if (PyErr_Occurred()) SWIG_fail;
15030     }
15031     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSlider, 1);
15032     return resultobj;
15033     fail:
15034     return NULL;
15035 }
15036
15037
15038 static PyObject *_wrap_Slider_Create(PyObject *, PyObject *args, PyObject *kwargs) {
15039     PyObject *resultobj;
15040     wxSlider *arg1 = (wxSlider *) 0 ;
15041     wxWindow *arg2 = (wxWindow *) 0 ;
15042     int arg3 = (int) -1 ;
15043     int arg4 = (int) 0 ;
15044     int arg5 = (int) 0 ;
15045     int arg6 = (int) 100 ;
15046     wxPoint const &arg7_defvalue = wxDefaultPosition ;
15047     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
15048     wxSize const &arg8_defvalue = wxDefaultSize ;
15049     wxSize *arg8 = (wxSize *) &arg8_defvalue ;
15050     long arg9 = (long) wxSL_HORIZONTAL ;
15051     wxValidator const &arg10_defvalue = wxDefaultValidator ;
15052     wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
15053     wxString const &arg11_defvalue = wxPySliderNameStr ;
15054     wxString *arg11 = (wxString *) &arg11_defvalue ;
15055     bool result;
15056     wxPoint temp7 ;
15057     wxSize temp8 ;
15058     bool temp11 = false ;
15059     PyObject * obj0 = 0 ;
15060     PyObject * obj1 = 0 ;
15061     PyObject * obj2 = 0 ;
15062     PyObject * obj3 = 0 ;
15063     PyObject * obj4 = 0 ;
15064     PyObject * obj5 = 0 ;
15065     PyObject * obj6 = 0 ;
15066     PyObject * obj7 = 0 ;
15067     PyObject * obj8 = 0 ;
15068     PyObject * obj9 = 0 ;
15069     PyObject * obj10 = 0 ;
15070     char *kwnames[] = {
15071         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
15072     };
15073
15074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:Slider_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
15075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15076     if (SWIG_arg_fail(1)) SWIG_fail;
15077     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15078     if (SWIG_arg_fail(2)) SWIG_fail;
15079     if (obj2) {
15080         {
15081             arg3 = (int)(SWIG_As_int(obj2));
15082             if (SWIG_arg_fail(3)) SWIG_fail;
15083         }
15084     }
15085     if (obj3) {
15086         {
15087             arg4 = (int)(SWIG_As_int(obj3));
15088             if (SWIG_arg_fail(4)) SWIG_fail;
15089         }
15090     }
15091     if (obj4) {
15092         {
15093             arg5 = (int)(SWIG_As_int(obj4));
15094             if (SWIG_arg_fail(5)) SWIG_fail;
15095         }
15096     }
15097     if (obj5) {
15098         {
15099             arg6 = (int)(SWIG_As_int(obj5));
15100             if (SWIG_arg_fail(6)) SWIG_fail;
15101         }
15102     }
15103     if (obj6) {
15104         {
15105             arg7 = &temp7;
15106             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
15107         }
15108     }
15109     if (obj7) {
15110         {
15111             arg8 = &temp8;
15112             if ( ! wxSize_helper(obj7, &arg8)) SWIG_fail;
15113         }
15114     }
15115     if (obj8) {
15116         {
15117             arg9 = (long)(SWIG_As_long(obj8));
15118             if (SWIG_arg_fail(9)) SWIG_fail;
15119         }
15120     }
15121     if (obj9) {
15122         {
15123             SWIG_Python_ConvertPtr(obj9, (void **)&arg10, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
15124             if (SWIG_arg_fail(10)) SWIG_fail;
15125             if (arg10 == NULL) {
15126                 SWIG_null_ref("wxValidator");
15127             }
15128             if (SWIG_arg_fail(10)) SWIG_fail;
15129         }
15130     }
15131     if (obj10) {
15132         {
15133             arg11 = wxString_in_helper(obj10);
15134             if (arg11 == NULL) SWIG_fail;
15135             temp11 = true;
15136         }
15137     }
15138     {
15139         PyThreadState* __tstate = wxPyBeginAllowThreads();
15140         result = (bool)(arg1)->Create(arg2,arg3,arg4,arg5,arg6,(wxPoint const &)*arg7,(wxSize const &)*arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
15141
15142         wxPyEndAllowThreads(__tstate);
15143         if (PyErr_Occurred()) SWIG_fail;
15144     }
15145     {
15146         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15147     }
15148     {
15149         if (temp11)
15150         delete arg11;
15151     }
15152     return resultobj;
15153     fail:
15154     {
15155         if (temp11)
15156         delete arg11;
15157     }
15158     return NULL;
15159 }
15160
15161
15162 static PyObject *_wrap_Slider_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15163     PyObject *resultobj;
15164     wxSlider *arg1 = (wxSlider *) 0 ;
15165     int result;
15166     PyObject * obj0 = 0 ;
15167     char *kwnames[] = {
15168         (char *) "self", NULL
15169     };
15170
15171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetValue",kwnames,&obj0)) goto fail;
15172     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15173     if (SWIG_arg_fail(1)) SWIG_fail;
15174     {
15175         PyThreadState* __tstate = wxPyBeginAllowThreads();
15176         result = (int)((wxSlider const *)arg1)->GetValue();
15177
15178         wxPyEndAllowThreads(__tstate);
15179         if (PyErr_Occurred()) SWIG_fail;
15180     }
15181     {
15182         resultobj = SWIG_From_int((int)(result));
15183     }
15184     return resultobj;
15185     fail:
15186     return NULL;
15187 }
15188
15189
15190 static PyObject *_wrap_Slider_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15191     PyObject *resultobj;
15192     wxSlider *arg1 = (wxSlider *) 0 ;
15193     int arg2 ;
15194     PyObject * obj0 = 0 ;
15195     PyObject * obj1 = 0 ;
15196     char *kwnames[] = {
15197         (char *) "self",(char *) "value", NULL
15198     };
15199
15200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetValue",kwnames,&obj0,&obj1)) goto fail;
15201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15202     if (SWIG_arg_fail(1)) SWIG_fail;
15203     {
15204         arg2 = (int)(SWIG_As_int(obj1));
15205         if (SWIG_arg_fail(2)) SWIG_fail;
15206     }
15207     {
15208         PyThreadState* __tstate = wxPyBeginAllowThreads();
15209         (arg1)->SetValue(arg2);
15210
15211         wxPyEndAllowThreads(__tstate);
15212         if (PyErr_Occurred()) SWIG_fail;
15213     }
15214     Py_INCREF(Py_None); resultobj = Py_None;
15215     return resultobj;
15216     fail:
15217     return NULL;
15218 }
15219
15220
15221 static PyObject *_wrap_Slider_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15222     PyObject *resultobj;
15223     wxSlider *arg1 = (wxSlider *) 0 ;
15224     int arg2 ;
15225     int arg3 ;
15226     PyObject * obj0 = 0 ;
15227     PyObject * obj1 = 0 ;
15228     PyObject * obj2 = 0 ;
15229     char *kwnames[] = {
15230         (char *) "self",(char *) "minValue",(char *) "maxValue", NULL
15231     };
15232
15233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15235     if (SWIG_arg_fail(1)) SWIG_fail;
15236     {
15237         arg2 = (int)(SWIG_As_int(obj1));
15238         if (SWIG_arg_fail(2)) SWIG_fail;
15239     }
15240     {
15241         arg3 = (int)(SWIG_As_int(obj2));
15242         if (SWIG_arg_fail(3)) SWIG_fail;
15243     }
15244     {
15245         PyThreadState* __tstate = wxPyBeginAllowThreads();
15246         (arg1)->SetRange(arg2,arg3);
15247
15248         wxPyEndAllowThreads(__tstate);
15249         if (PyErr_Occurred()) SWIG_fail;
15250     }
15251     Py_INCREF(Py_None); resultobj = Py_None;
15252     return resultobj;
15253     fail:
15254     return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_Slider_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
15259     PyObject *resultobj;
15260     wxSlider *arg1 = (wxSlider *) 0 ;
15261     int result;
15262     PyObject * obj0 = 0 ;
15263     char *kwnames[] = {
15264         (char *) "self", NULL
15265     };
15266
15267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetMin",kwnames,&obj0)) goto fail;
15268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15269     if (SWIG_arg_fail(1)) SWIG_fail;
15270     {
15271         PyThreadState* __tstate = wxPyBeginAllowThreads();
15272         result = (int)((wxSlider const *)arg1)->GetMin();
15273
15274         wxPyEndAllowThreads(__tstate);
15275         if (PyErr_Occurred()) SWIG_fail;
15276     }
15277     {
15278         resultobj = SWIG_From_int((int)(result));
15279     }
15280     return resultobj;
15281     fail:
15282     return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_Slider_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
15287     PyObject *resultobj;
15288     wxSlider *arg1 = (wxSlider *) 0 ;
15289     int result;
15290     PyObject * obj0 = 0 ;
15291     char *kwnames[] = {
15292         (char *) "self", NULL
15293     };
15294
15295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetMax",kwnames,&obj0)) goto fail;
15296     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15297     if (SWIG_arg_fail(1)) SWIG_fail;
15298     {
15299         PyThreadState* __tstate = wxPyBeginAllowThreads();
15300         result = (int)((wxSlider const *)arg1)->GetMax();
15301
15302         wxPyEndAllowThreads(__tstate);
15303         if (PyErr_Occurred()) SWIG_fail;
15304     }
15305     {
15306         resultobj = SWIG_From_int((int)(result));
15307     }
15308     return resultobj;
15309     fail:
15310     return NULL;
15311 }
15312
15313
15314 static PyObject *_wrap_Slider_SetMin(PyObject *, PyObject *args, PyObject *kwargs) {
15315     PyObject *resultobj;
15316     wxSlider *arg1 = (wxSlider *) 0 ;
15317     int arg2 ;
15318     PyObject * obj0 = 0 ;
15319     PyObject * obj1 = 0 ;
15320     char *kwnames[] = {
15321         (char *) "self",(char *) "minValue", NULL
15322     };
15323
15324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMin",kwnames,&obj0,&obj1)) goto fail;
15325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15326     if (SWIG_arg_fail(1)) SWIG_fail;
15327     {
15328         arg2 = (int)(SWIG_As_int(obj1));
15329         if (SWIG_arg_fail(2)) SWIG_fail;
15330     }
15331     {
15332         PyThreadState* __tstate = wxPyBeginAllowThreads();
15333         (arg1)->SetMin(arg2);
15334
15335         wxPyEndAllowThreads(__tstate);
15336         if (PyErr_Occurred()) SWIG_fail;
15337     }
15338     Py_INCREF(Py_None); resultobj = Py_None;
15339     return resultobj;
15340     fail:
15341     return NULL;
15342 }
15343
15344
15345 static PyObject *_wrap_Slider_SetMax(PyObject *, PyObject *args, PyObject *kwargs) {
15346     PyObject *resultobj;
15347     wxSlider *arg1 = (wxSlider *) 0 ;
15348     int arg2 ;
15349     PyObject * obj0 = 0 ;
15350     PyObject * obj1 = 0 ;
15351     char *kwnames[] = {
15352         (char *) "self",(char *) "maxValue", NULL
15353     };
15354
15355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMax",kwnames,&obj0,&obj1)) goto fail;
15356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15357     if (SWIG_arg_fail(1)) SWIG_fail;
15358     {
15359         arg2 = (int)(SWIG_As_int(obj1));
15360         if (SWIG_arg_fail(2)) SWIG_fail;
15361     }
15362     {
15363         PyThreadState* __tstate = wxPyBeginAllowThreads();
15364         (arg1)->SetMax(arg2);
15365
15366         wxPyEndAllowThreads(__tstate);
15367         if (PyErr_Occurred()) SWIG_fail;
15368     }
15369     Py_INCREF(Py_None); resultobj = Py_None;
15370     return resultobj;
15371     fail:
15372     return NULL;
15373 }
15374
15375
15376 static PyObject *_wrap_Slider_SetLineSize(PyObject *, PyObject *args, PyObject *kwargs) {
15377     PyObject *resultobj;
15378     wxSlider *arg1 = (wxSlider *) 0 ;
15379     int arg2 ;
15380     PyObject * obj0 = 0 ;
15381     PyObject * obj1 = 0 ;
15382     char *kwnames[] = {
15383         (char *) "self",(char *) "lineSize", NULL
15384     };
15385
15386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetLineSize",kwnames,&obj0,&obj1)) goto fail;
15387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15388     if (SWIG_arg_fail(1)) SWIG_fail;
15389     {
15390         arg2 = (int)(SWIG_As_int(obj1));
15391         if (SWIG_arg_fail(2)) SWIG_fail;
15392     }
15393     {
15394         PyThreadState* __tstate = wxPyBeginAllowThreads();
15395         (arg1)->SetLineSize(arg2);
15396
15397         wxPyEndAllowThreads(__tstate);
15398         if (PyErr_Occurred()) SWIG_fail;
15399     }
15400     Py_INCREF(Py_None); resultobj = Py_None;
15401     return resultobj;
15402     fail:
15403     return NULL;
15404 }
15405
15406
15407 static PyObject *_wrap_Slider_SetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
15408     PyObject *resultobj;
15409     wxSlider *arg1 = (wxSlider *) 0 ;
15410     int arg2 ;
15411     PyObject * obj0 = 0 ;
15412     PyObject * obj1 = 0 ;
15413     char *kwnames[] = {
15414         (char *) "self",(char *) "pageSize", NULL
15415     };
15416
15417     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetPageSize",kwnames,&obj0,&obj1)) goto fail;
15418     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15419     if (SWIG_arg_fail(1)) SWIG_fail;
15420     {
15421         arg2 = (int)(SWIG_As_int(obj1));
15422         if (SWIG_arg_fail(2)) SWIG_fail;
15423     }
15424     {
15425         PyThreadState* __tstate = wxPyBeginAllowThreads();
15426         (arg1)->SetPageSize(arg2);
15427
15428         wxPyEndAllowThreads(__tstate);
15429         if (PyErr_Occurred()) SWIG_fail;
15430     }
15431     Py_INCREF(Py_None); resultobj = Py_None;
15432     return resultobj;
15433     fail:
15434     return NULL;
15435 }
15436
15437
15438 static PyObject *_wrap_Slider_GetLineSize(PyObject *, PyObject *args, PyObject *kwargs) {
15439     PyObject *resultobj;
15440     wxSlider *arg1 = (wxSlider *) 0 ;
15441     int result;
15442     PyObject * obj0 = 0 ;
15443     char *kwnames[] = {
15444         (char *) "self", NULL
15445     };
15446
15447     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetLineSize",kwnames,&obj0)) goto fail;
15448     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15449     if (SWIG_arg_fail(1)) SWIG_fail;
15450     {
15451         PyThreadState* __tstate = wxPyBeginAllowThreads();
15452         result = (int)((wxSlider const *)arg1)->GetLineSize();
15453
15454         wxPyEndAllowThreads(__tstate);
15455         if (PyErr_Occurred()) SWIG_fail;
15456     }
15457     {
15458         resultobj = SWIG_From_int((int)(result));
15459     }
15460     return resultobj;
15461     fail:
15462     return NULL;
15463 }
15464
15465
15466 static PyObject *_wrap_Slider_GetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
15467     PyObject *resultobj;
15468     wxSlider *arg1 = (wxSlider *) 0 ;
15469     int result;
15470     PyObject * obj0 = 0 ;
15471     char *kwnames[] = {
15472         (char *) "self", NULL
15473     };
15474
15475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetPageSize",kwnames,&obj0)) goto fail;
15476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15477     if (SWIG_arg_fail(1)) SWIG_fail;
15478     {
15479         PyThreadState* __tstate = wxPyBeginAllowThreads();
15480         result = (int)((wxSlider const *)arg1)->GetPageSize();
15481
15482         wxPyEndAllowThreads(__tstate);
15483         if (PyErr_Occurred()) SWIG_fail;
15484     }
15485     {
15486         resultobj = SWIG_From_int((int)(result));
15487     }
15488     return resultobj;
15489     fail:
15490     return NULL;
15491 }
15492
15493
15494 static PyObject *_wrap_Slider_SetThumbLength(PyObject *, PyObject *args, PyObject *kwargs) {
15495     PyObject *resultobj;
15496     wxSlider *arg1 = (wxSlider *) 0 ;
15497     int arg2 ;
15498     PyObject * obj0 = 0 ;
15499     PyObject * obj1 = 0 ;
15500     char *kwnames[] = {
15501         (char *) "self",(char *) "lenPixels", NULL
15502     };
15503
15504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetThumbLength",kwnames,&obj0,&obj1)) goto fail;
15505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15506     if (SWIG_arg_fail(1)) SWIG_fail;
15507     {
15508         arg2 = (int)(SWIG_As_int(obj1));
15509         if (SWIG_arg_fail(2)) SWIG_fail;
15510     }
15511     {
15512         PyThreadState* __tstate = wxPyBeginAllowThreads();
15513         (arg1)->SetThumbLength(arg2);
15514
15515         wxPyEndAllowThreads(__tstate);
15516         if (PyErr_Occurred()) SWIG_fail;
15517     }
15518     Py_INCREF(Py_None); resultobj = Py_None;
15519     return resultobj;
15520     fail:
15521     return NULL;
15522 }
15523
15524
15525 static PyObject *_wrap_Slider_GetThumbLength(PyObject *, PyObject *args, PyObject *kwargs) {
15526     PyObject *resultobj;
15527     wxSlider *arg1 = (wxSlider *) 0 ;
15528     int result;
15529     PyObject * obj0 = 0 ;
15530     char *kwnames[] = {
15531         (char *) "self", NULL
15532     };
15533
15534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetThumbLength",kwnames,&obj0)) goto fail;
15535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15536     if (SWIG_arg_fail(1)) SWIG_fail;
15537     {
15538         PyThreadState* __tstate = wxPyBeginAllowThreads();
15539         result = (int)((wxSlider const *)arg1)->GetThumbLength();
15540
15541         wxPyEndAllowThreads(__tstate);
15542         if (PyErr_Occurred()) SWIG_fail;
15543     }
15544     {
15545         resultobj = SWIG_From_int((int)(result));
15546     }
15547     return resultobj;
15548     fail:
15549     return NULL;
15550 }
15551
15552
15553 static PyObject *_wrap_Slider_SetTickFreq(PyObject *, PyObject *args, PyObject *kwargs) {
15554     PyObject *resultobj;
15555     wxSlider *arg1 = (wxSlider *) 0 ;
15556     int arg2 ;
15557     int arg3 = (int) 1 ;
15558     PyObject * obj0 = 0 ;
15559     PyObject * obj1 = 0 ;
15560     PyObject * obj2 = 0 ;
15561     char *kwnames[] = {
15562         (char *) "self",(char *) "n",(char *) "pos", NULL
15563     };
15564
15565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Slider_SetTickFreq",kwnames,&obj0,&obj1,&obj2)) goto fail;
15566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15567     if (SWIG_arg_fail(1)) SWIG_fail;
15568     {
15569         arg2 = (int)(SWIG_As_int(obj1));
15570         if (SWIG_arg_fail(2)) SWIG_fail;
15571     }
15572     if (obj2) {
15573         {
15574             arg3 = (int)(SWIG_As_int(obj2));
15575             if (SWIG_arg_fail(3)) SWIG_fail;
15576         }
15577     }
15578     {
15579         PyThreadState* __tstate = wxPyBeginAllowThreads();
15580         (arg1)->SetTickFreq(arg2,arg3);
15581
15582         wxPyEndAllowThreads(__tstate);
15583         if (PyErr_Occurred()) SWIG_fail;
15584     }
15585     Py_INCREF(Py_None); resultobj = Py_None;
15586     return resultobj;
15587     fail:
15588     return NULL;
15589 }
15590
15591
15592 static PyObject *_wrap_Slider_GetTickFreq(PyObject *, PyObject *args, PyObject *kwargs) {
15593     PyObject *resultobj;
15594     wxSlider *arg1 = (wxSlider *) 0 ;
15595     int result;
15596     PyObject * obj0 = 0 ;
15597     char *kwnames[] = {
15598         (char *) "self", NULL
15599     };
15600
15601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetTickFreq",kwnames,&obj0)) goto fail;
15602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15603     if (SWIG_arg_fail(1)) SWIG_fail;
15604     {
15605         PyThreadState* __tstate = wxPyBeginAllowThreads();
15606         result = (int)((wxSlider const *)arg1)->GetTickFreq();
15607
15608         wxPyEndAllowThreads(__tstate);
15609         if (PyErr_Occurred()) SWIG_fail;
15610     }
15611     {
15612         resultobj = SWIG_From_int((int)(result));
15613     }
15614     return resultobj;
15615     fail:
15616     return NULL;
15617 }
15618
15619
15620 static PyObject *_wrap_Slider_ClearTicks(PyObject *, PyObject *args, PyObject *kwargs) {
15621     PyObject *resultobj;
15622     wxSlider *arg1 = (wxSlider *) 0 ;
15623     PyObject * obj0 = 0 ;
15624     char *kwnames[] = {
15625         (char *) "self", NULL
15626     };
15627
15628     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_ClearTicks",kwnames,&obj0)) goto fail;
15629     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15630     if (SWIG_arg_fail(1)) SWIG_fail;
15631     {
15632         PyThreadState* __tstate = wxPyBeginAllowThreads();
15633         (arg1)->ClearTicks();
15634
15635         wxPyEndAllowThreads(__tstate);
15636         if (PyErr_Occurred()) SWIG_fail;
15637     }
15638     Py_INCREF(Py_None); resultobj = Py_None;
15639     return resultobj;
15640     fail:
15641     return NULL;
15642 }
15643
15644
15645 static PyObject *_wrap_Slider_SetTick(PyObject *, PyObject *args, PyObject *kwargs) {
15646     PyObject *resultobj;
15647     wxSlider *arg1 = (wxSlider *) 0 ;
15648     int arg2 ;
15649     PyObject * obj0 = 0 ;
15650     PyObject * obj1 = 0 ;
15651     char *kwnames[] = {
15652         (char *) "self",(char *) "tickPos", NULL
15653     };
15654
15655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetTick",kwnames,&obj0,&obj1)) goto fail;
15656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15657     if (SWIG_arg_fail(1)) SWIG_fail;
15658     {
15659         arg2 = (int)(SWIG_As_int(obj1));
15660         if (SWIG_arg_fail(2)) SWIG_fail;
15661     }
15662     {
15663         PyThreadState* __tstate = wxPyBeginAllowThreads();
15664         (arg1)->SetTick(arg2);
15665
15666         wxPyEndAllowThreads(__tstate);
15667         if (PyErr_Occurred()) SWIG_fail;
15668     }
15669     Py_INCREF(Py_None); resultobj = Py_None;
15670     return resultobj;
15671     fail:
15672     return NULL;
15673 }
15674
15675
15676 static PyObject *_wrap_Slider_ClearSel(PyObject *, PyObject *args, PyObject *kwargs) {
15677     PyObject *resultobj;
15678     wxSlider *arg1 = (wxSlider *) 0 ;
15679     PyObject * obj0 = 0 ;
15680     char *kwnames[] = {
15681         (char *) "self", NULL
15682     };
15683
15684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_ClearSel",kwnames,&obj0)) goto fail;
15685     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15686     if (SWIG_arg_fail(1)) SWIG_fail;
15687     {
15688         PyThreadState* __tstate = wxPyBeginAllowThreads();
15689         (arg1)->ClearSel();
15690
15691         wxPyEndAllowThreads(__tstate);
15692         if (PyErr_Occurred()) SWIG_fail;
15693     }
15694     Py_INCREF(Py_None); resultobj = Py_None;
15695     return resultobj;
15696     fail:
15697     return NULL;
15698 }
15699
15700
15701 static PyObject *_wrap_Slider_GetSelEnd(PyObject *, PyObject *args, PyObject *kwargs) {
15702     PyObject *resultobj;
15703     wxSlider *arg1 = (wxSlider *) 0 ;
15704     int result;
15705     PyObject * obj0 = 0 ;
15706     char *kwnames[] = {
15707         (char *) "self", NULL
15708     };
15709
15710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetSelEnd",kwnames,&obj0)) goto fail;
15711     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15712     if (SWIG_arg_fail(1)) SWIG_fail;
15713     {
15714         PyThreadState* __tstate = wxPyBeginAllowThreads();
15715         result = (int)((wxSlider const *)arg1)->GetSelEnd();
15716
15717         wxPyEndAllowThreads(__tstate);
15718         if (PyErr_Occurred()) SWIG_fail;
15719     }
15720     {
15721         resultobj = SWIG_From_int((int)(result));
15722     }
15723     return resultobj;
15724     fail:
15725     return NULL;
15726 }
15727
15728
15729 static PyObject *_wrap_Slider_GetSelStart(PyObject *, PyObject *args, PyObject *kwargs) {
15730     PyObject *resultobj;
15731     wxSlider *arg1 = (wxSlider *) 0 ;
15732     int result;
15733     PyObject * obj0 = 0 ;
15734     char *kwnames[] = {
15735         (char *) "self", NULL
15736     };
15737
15738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetSelStart",kwnames,&obj0)) goto fail;
15739     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15740     if (SWIG_arg_fail(1)) SWIG_fail;
15741     {
15742         PyThreadState* __tstate = wxPyBeginAllowThreads();
15743         result = (int)((wxSlider const *)arg1)->GetSelStart();
15744
15745         wxPyEndAllowThreads(__tstate);
15746         if (PyErr_Occurred()) SWIG_fail;
15747     }
15748     {
15749         resultobj = SWIG_From_int((int)(result));
15750     }
15751     return resultobj;
15752     fail:
15753     return NULL;
15754 }
15755
15756
15757 static PyObject *_wrap_Slider_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15758     PyObject *resultobj;
15759     wxSlider *arg1 = (wxSlider *) 0 ;
15760     int arg2 ;
15761     int arg3 ;
15762     PyObject * obj0 = 0 ;
15763     PyObject * obj1 = 0 ;
15764     PyObject * obj2 = 0 ;
15765     char *kwnames[] = {
15766         (char *) "self",(char *) "min",(char *) "max", NULL
15767     };
15768
15769     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15770     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15771     if (SWIG_arg_fail(1)) SWIG_fail;
15772     {
15773         arg2 = (int)(SWIG_As_int(obj1));
15774         if (SWIG_arg_fail(2)) SWIG_fail;
15775     }
15776     {
15777         arg3 = (int)(SWIG_As_int(obj2));
15778         if (SWIG_arg_fail(3)) SWIG_fail;
15779     }
15780     {
15781         PyThreadState* __tstate = wxPyBeginAllowThreads();
15782         (arg1)->SetSelection(arg2,arg3);
15783
15784         wxPyEndAllowThreads(__tstate);
15785         if (PyErr_Occurred()) SWIG_fail;
15786     }
15787     Py_INCREF(Py_None); resultobj = Py_None;
15788     return resultobj;
15789     fail:
15790     return NULL;
15791 }
15792
15793
15794 static PyObject *_wrap_Slider_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
15795     PyObject *resultobj;
15796     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
15797     wxVisualAttributes result;
15798     PyObject * obj0 = 0 ;
15799     char *kwnames[] = {
15800         (char *) "variant", NULL
15801     };
15802
15803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Slider_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
15804     if (obj0) {
15805         {
15806             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
15807             if (SWIG_arg_fail(1)) SWIG_fail;
15808         }
15809     }
15810     {
15811         if (!wxPyCheckForApp()) SWIG_fail;
15812         PyThreadState* __tstate = wxPyBeginAllowThreads();
15813         result = wxSlider::GetClassDefaultAttributes((wxWindowVariant )arg1);
15814
15815         wxPyEndAllowThreads(__tstate);
15816         if (PyErr_Occurred()) SWIG_fail;
15817     }
15818     {
15819         wxVisualAttributes * resultptr;
15820         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
15821         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
15822     }
15823     return resultobj;
15824     fail:
15825     return NULL;
15826 }
15827
15828
15829 static PyObject * Slider_swigregister(PyObject *, PyObject *args) {
15830     PyObject *obj;
15831     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15832     SWIG_TypeClientData(SWIGTYPE_p_wxSlider, obj);
15833     Py_INCREF(obj);
15834     return Py_BuildValue((char *)"");
15835 }
15836 static int _wrap_ToggleButtonNameStr_set(PyObject *) {
15837     PyErr_SetString(PyExc_TypeError,"Variable ToggleButtonNameStr is read-only.");
15838     return 1;
15839 }
15840
15841
15842 static PyObject *_wrap_ToggleButtonNameStr_get(void) {
15843     PyObject *pyobj;
15844
15845     {
15846 #if wxUSE_UNICODE
15847         pyobj = PyUnicode_FromWideChar((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
15848 #else
15849         pyobj = PyString_FromStringAndSize((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
15850 #endif
15851     }
15852     return pyobj;
15853 }
15854
15855
15856 static PyObject *_wrap_new_ToggleButton(PyObject *, PyObject *args, PyObject *kwargs) {
15857     PyObject *resultobj;
15858     wxWindow *arg1 = (wxWindow *) 0 ;
15859     int arg2 = (int) -1 ;
15860     wxString const &arg3_defvalue = wxPyEmptyString ;
15861     wxString *arg3 = (wxString *) &arg3_defvalue ;
15862     wxPoint const &arg4_defvalue = wxDefaultPosition ;
15863     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
15864     wxSize const &arg5_defvalue = wxDefaultSize ;
15865     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
15866     long arg6 = (long) 0 ;
15867     wxValidator const &arg7_defvalue = wxDefaultValidator ;
15868     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
15869     wxString const &arg8_defvalue = wxPyToggleButtonNameStr ;
15870     wxString *arg8 = (wxString *) &arg8_defvalue ;
15871     wxToggleButton *result;
15872     bool temp3 = false ;
15873     wxPoint temp4 ;
15874     wxSize temp5 ;
15875     bool temp8 = false ;
15876     PyObject * obj0 = 0 ;
15877     PyObject * obj1 = 0 ;
15878     PyObject * obj2 = 0 ;
15879     PyObject * obj3 = 0 ;
15880     PyObject * obj4 = 0 ;
15881     PyObject * obj5 = 0 ;
15882     PyObject * obj6 = 0 ;
15883     PyObject * obj7 = 0 ;
15884     char *kwnames[] = {
15885         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
15886     };
15887
15888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ToggleButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
15889     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15890     if (SWIG_arg_fail(1)) SWIG_fail;
15891     if (obj1) {
15892         {
15893             arg2 = (int)(SWIG_As_int(obj1));
15894             if (SWIG_arg_fail(2)) SWIG_fail;
15895         }
15896     }
15897     if (obj2) {
15898         {
15899             arg3 = wxString_in_helper(obj2);
15900             if (arg3 == NULL) SWIG_fail;
15901             temp3 = true;
15902         }
15903     }
15904     if (obj3) {
15905         {
15906             arg4 = &temp4;
15907             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
15908         }
15909     }
15910     if (obj4) {
15911         {
15912             arg5 = &temp5;
15913             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
15914         }
15915     }
15916     if (obj5) {
15917         {
15918             arg6 = (long)(SWIG_As_long(obj5));
15919             if (SWIG_arg_fail(6)) SWIG_fail;
15920         }
15921     }
15922     if (obj6) {
15923         {
15924             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
15925             if (SWIG_arg_fail(7)) SWIG_fail;
15926             if (arg7 == NULL) {
15927                 SWIG_null_ref("wxValidator");
15928             }
15929             if (SWIG_arg_fail(7)) SWIG_fail;
15930         }
15931     }
15932     if (obj7) {
15933         {
15934             arg8 = wxString_in_helper(obj7);
15935             if (arg8 == NULL) SWIG_fail;
15936             temp8 = true;
15937         }
15938     }
15939     {
15940         if (!wxPyCheckForApp()) SWIG_fail;
15941         PyThreadState* __tstate = wxPyBeginAllowThreads();
15942         result = (wxToggleButton *)new wxToggleButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
15943
15944         wxPyEndAllowThreads(__tstate);
15945         if (PyErr_Occurred()) SWIG_fail;
15946     }
15947     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToggleButton, 1);
15948     {
15949         if (temp3)
15950         delete arg3;
15951     }
15952     {
15953         if (temp8)
15954         delete arg8;
15955     }
15956     return resultobj;
15957     fail:
15958     {
15959         if (temp3)
15960         delete arg3;
15961     }
15962     {
15963         if (temp8)
15964         delete arg8;
15965     }
15966     return NULL;
15967 }
15968
15969
15970 static PyObject *_wrap_new_PreToggleButton(PyObject *, PyObject *args, PyObject *kwargs) {
15971     PyObject *resultobj;
15972     wxToggleButton *result;
15973     char *kwnames[] = {
15974         NULL
15975     };
15976
15977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreToggleButton",kwnames)) goto fail;
15978     {
15979         if (!wxPyCheckForApp()) SWIG_fail;
15980         PyThreadState* __tstate = wxPyBeginAllowThreads();
15981         result = (wxToggleButton *)new wxToggleButton();
15982
15983         wxPyEndAllowThreads(__tstate);
15984         if (PyErr_Occurred()) SWIG_fail;
15985     }
15986     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToggleButton, 1);
15987     return resultobj;
15988     fail:
15989     return NULL;
15990 }
15991
15992
15993 static PyObject *_wrap_ToggleButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
15994     PyObject *resultobj;
15995     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
15996     wxWindow *arg2 = (wxWindow *) 0 ;
15997     int arg3 = (int) -1 ;
15998     wxString const &arg4_defvalue = wxPyEmptyString ;
15999     wxString *arg4 = (wxString *) &arg4_defvalue ;
16000     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16001     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16002     wxSize const &arg6_defvalue = wxDefaultSize ;
16003     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16004     long arg7 = (long) 0 ;
16005     wxValidator const &arg8_defvalue = wxDefaultValidator ;
16006     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
16007     wxString const &arg9_defvalue = wxPyToggleButtonNameStr ;
16008     wxString *arg9 = (wxString *) &arg9_defvalue ;
16009     bool result;
16010     bool temp4 = false ;
16011     wxPoint temp5 ;
16012     wxSize temp6 ;
16013     bool temp9 = false ;
16014     PyObject * obj0 = 0 ;
16015     PyObject * obj1 = 0 ;
16016     PyObject * obj2 = 0 ;
16017     PyObject * obj3 = 0 ;
16018     PyObject * obj4 = 0 ;
16019     PyObject * obj5 = 0 ;
16020     PyObject * obj6 = 0 ;
16021     PyObject * obj7 = 0 ;
16022     PyObject * obj8 = 0 ;
16023     char *kwnames[] = {
16024         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
16025     };
16026
16027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ToggleButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
16028     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16029     if (SWIG_arg_fail(1)) SWIG_fail;
16030     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16031     if (SWIG_arg_fail(2)) SWIG_fail;
16032     if (obj2) {
16033         {
16034             arg3 = (int)(SWIG_As_int(obj2));
16035             if (SWIG_arg_fail(3)) SWIG_fail;
16036         }
16037     }
16038     if (obj3) {
16039         {
16040             arg4 = wxString_in_helper(obj3);
16041             if (arg4 == NULL) SWIG_fail;
16042             temp4 = true;
16043         }
16044     }
16045     if (obj4) {
16046         {
16047             arg5 = &temp5;
16048             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16049         }
16050     }
16051     if (obj5) {
16052         {
16053             arg6 = &temp6;
16054             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16055         }
16056     }
16057     if (obj6) {
16058         {
16059             arg7 = (long)(SWIG_As_long(obj6));
16060             if (SWIG_arg_fail(7)) SWIG_fail;
16061         }
16062     }
16063     if (obj7) {
16064         {
16065             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
16066             if (SWIG_arg_fail(8)) SWIG_fail;
16067             if (arg8 == NULL) {
16068                 SWIG_null_ref("wxValidator");
16069             }
16070             if (SWIG_arg_fail(8)) SWIG_fail;
16071         }
16072     }
16073     if (obj8) {
16074         {
16075             arg9 = wxString_in_helper(obj8);
16076             if (arg9 == NULL) SWIG_fail;
16077             temp9 = true;
16078         }
16079     }
16080     {
16081         PyThreadState* __tstate = wxPyBeginAllowThreads();
16082         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
16083
16084         wxPyEndAllowThreads(__tstate);
16085         if (PyErr_Occurred()) SWIG_fail;
16086     }
16087     {
16088         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16089     }
16090     {
16091         if (temp4)
16092         delete arg4;
16093     }
16094     {
16095         if (temp9)
16096         delete arg9;
16097     }
16098     return resultobj;
16099     fail:
16100     {
16101         if (temp4)
16102         delete arg4;
16103     }
16104     {
16105         if (temp9)
16106         delete arg9;
16107     }
16108     return NULL;
16109 }
16110
16111
16112 static PyObject *_wrap_ToggleButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
16113     PyObject *resultobj;
16114     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16115     bool arg2 ;
16116     PyObject * obj0 = 0 ;
16117     PyObject * obj1 = 0 ;
16118     char *kwnames[] = {
16119         (char *) "self",(char *) "value", NULL
16120     };
16121
16122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToggleButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
16123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16124     if (SWIG_arg_fail(1)) SWIG_fail;
16125     {
16126         arg2 = (bool)(SWIG_As_bool(obj1));
16127         if (SWIG_arg_fail(2)) SWIG_fail;
16128     }
16129     {
16130         PyThreadState* __tstate = wxPyBeginAllowThreads();
16131         (arg1)->SetValue(arg2);
16132
16133         wxPyEndAllowThreads(__tstate);
16134         if (PyErr_Occurred()) SWIG_fail;
16135     }
16136     Py_INCREF(Py_None); resultobj = Py_None;
16137     return resultobj;
16138     fail:
16139     return NULL;
16140 }
16141
16142
16143 static PyObject *_wrap_ToggleButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
16144     PyObject *resultobj;
16145     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16146     bool result;
16147     PyObject * obj0 = 0 ;
16148     char *kwnames[] = {
16149         (char *) "self", NULL
16150     };
16151
16152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToggleButton_GetValue",kwnames,&obj0)) goto fail;
16153     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16154     if (SWIG_arg_fail(1)) SWIG_fail;
16155     {
16156         PyThreadState* __tstate = wxPyBeginAllowThreads();
16157         result = (bool)((wxToggleButton const *)arg1)->GetValue();
16158
16159         wxPyEndAllowThreads(__tstate);
16160         if (PyErr_Occurred()) SWIG_fail;
16161     }
16162     {
16163         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16164     }
16165     return resultobj;
16166     fail:
16167     return NULL;
16168 }
16169
16170
16171 static PyObject *_wrap_ToggleButton_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
16172     PyObject *resultobj;
16173     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16174     wxString *arg2 = 0 ;
16175     bool temp2 = false ;
16176     PyObject * obj0 = 0 ;
16177     PyObject * obj1 = 0 ;
16178     char *kwnames[] = {
16179         (char *) "self",(char *) "label", NULL
16180     };
16181
16182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToggleButton_SetLabel",kwnames,&obj0,&obj1)) goto fail;
16183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16184     if (SWIG_arg_fail(1)) SWIG_fail;
16185     {
16186         arg2 = wxString_in_helper(obj1);
16187         if (arg2 == NULL) SWIG_fail;
16188         temp2 = true;
16189     }
16190     {
16191         PyThreadState* __tstate = wxPyBeginAllowThreads();
16192         (arg1)->SetLabel((wxString const &)*arg2);
16193
16194         wxPyEndAllowThreads(__tstate);
16195         if (PyErr_Occurred()) SWIG_fail;
16196     }
16197     Py_INCREF(Py_None); resultobj = Py_None;
16198     {
16199         if (temp2)
16200         delete arg2;
16201     }
16202     return resultobj;
16203     fail:
16204     {
16205         if (temp2)
16206         delete arg2;
16207     }
16208     return NULL;
16209 }
16210
16211
16212 static PyObject *_wrap_ToggleButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16213     PyObject *resultobj;
16214     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16215     wxVisualAttributes result;
16216     PyObject * obj0 = 0 ;
16217     char *kwnames[] = {
16218         (char *) "variant", NULL
16219     };
16220
16221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToggleButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16222     if (obj0) {
16223         {
16224             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16225             if (SWIG_arg_fail(1)) SWIG_fail;
16226         }
16227     }
16228     {
16229         if (!wxPyCheckForApp()) SWIG_fail;
16230         PyThreadState* __tstate = wxPyBeginAllowThreads();
16231         result = wxToggleButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
16232
16233         wxPyEndAllowThreads(__tstate);
16234         if (PyErr_Occurred()) SWIG_fail;
16235     }
16236     {
16237         wxVisualAttributes * resultptr;
16238         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16239         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16240     }
16241     return resultobj;
16242     fail:
16243     return NULL;
16244 }
16245
16246
16247 static PyObject * ToggleButton_swigregister(PyObject *, PyObject *args) {
16248     PyObject *obj;
16249     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16250     SWIG_TypeClientData(SWIGTYPE_p_wxToggleButton, obj);
16251     Py_INCREF(obj);
16252     return Py_BuildValue((char *)"");
16253 }
16254 static int _wrap_NOTEBOOK_NAME_set(PyObject *) {
16255     PyErr_SetString(PyExc_TypeError,"Variable NOTEBOOK_NAME is read-only.");
16256     return 1;
16257 }
16258
16259
16260 static PyObject *_wrap_NOTEBOOK_NAME_get(void) {
16261     PyObject *pyobj;
16262
16263     {
16264 #if wxUSE_UNICODE
16265         pyobj = PyUnicode_FromWideChar((&wxPyNOTEBOOK_NAME)->c_str(), (&wxPyNOTEBOOK_NAME)->Len());
16266 #else
16267         pyobj = PyString_FromStringAndSize((&wxPyNOTEBOOK_NAME)->c_str(), (&wxPyNOTEBOOK_NAME)->Len());
16268 #endif
16269     }
16270     return pyobj;
16271 }
16272
16273
16274 static PyObject *_wrap_BookCtrlBase_GetPageCount(PyObject *, PyObject *args, PyObject *kwargs) {
16275     PyObject *resultobj;
16276     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16277     size_t result;
16278     PyObject * obj0 = 0 ;
16279     char *kwnames[] = {
16280         (char *) "self", NULL
16281     };
16282
16283     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetPageCount",kwnames,&obj0)) goto fail;
16284     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16285     if (SWIG_arg_fail(1)) SWIG_fail;
16286     {
16287         PyThreadState* __tstate = wxPyBeginAllowThreads();
16288         result = (size_t)((wxBookCtrlBase const *)arg1)->GetPageCount();
16289
16290         wxPyEndAllowThreads(__tstate);
16291         if (PyErr_Occurred()) SWIG_fail;
16292     }
16293     {
16294         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16295     }
16296     return resultobj;
16297     fail:
16298     return NULL;
16299 }
16300
16301
16302 static PyObject *_wrap_BookCtrlBase_GetPage(PyObject *, PyObject *args, PyObject *kwargs) {
16303     PyObject *resultobj;
16304     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16305     size_t arg2 ;
16306     wxWindow *result;
16307     PyObject * obj0 = 0 ;
16308     PyObject * obj1 = 0 ;
16309     char *kwnames[] = {
16310         (char *) "self",(char *) "n", NULL
16311     };
16312
16313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPage",kwnames,&obj0,&obj1)) goto fail;
16314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16315     if (SWIG_arg_fail(1)) SWIG_fail;
16316     {
16317         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16318         if (SWIG_arg_fail(2)) SWIG_fail;
16319     }
16320     {
16321         PyThreadState* __tstate = wxPyBeginAllowThreads();
16322         result = (wxWindow *)(arg1)->GetPage(arg2);
16323
16324         wxPyEndAllowThreads(__tstate);
16325         if (PyErr_Occurred()) SWIG_fail;
16326     }
16327     {
16328         resultobj = wxPyMake_wxObject(result, 0);
16329     }
16330     return resultobj;
16331     fail:
16332     return NULL;
16333 }
16334
16335
16336 static PyObject *_wrap_BookCtrlBase_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
16337     PyObject *resultobj;
16338     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16339     wxWindow *result;
16340     PyObject * obj0 = 0 ;
16341     char *kwnames[] = {
16342         (char *) "self", NULL
16343     };
16344
16345     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetCurrentPage",kwnames,&obj0)) goto fail;
16346     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16347     if (SWIG_arg_fail(1)) SWIG_fail;
16348     {
16349         PyThreadState* __tstate = wxPyBeginAllowThreads();
16350         result = (wxWindow *)((wxBookCtrlBase const *)arg1)->GetCurrentPage();
16351
16352         wxPyEndAllowThreads(__tstate);
16353         if (PyErr_Occurred()) SWIG_fail;
16354     }
16355     {
16356         resultobj = wxPyMake_wxObject(result, 0);
16357     }
16358     return resultobj;
16359     fail:
16360     return NULL;
16361 }
16362
16363
16364 static PyObject *_wrap_BookCtrlBase_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16365     PyObject *resultobj;
16366     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16367     int result;
16368     PyObject * obj0 = 0 ;
16369     char *kwnames[] = {
16370         (char *) "self", NULL
16371     };
16372
16373     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetSelection",kwnames,&obj0)) goto fail;
16374     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16375     if (SWIG_arg_fail(1)) SWIG_fail;
16376     {
16377         PyThreadState* __tstate = wxPyBeginAllowThreads();
16378         result = (int)((wxBookCtrlBase const *)arg1)->GetSelection();
16379
16380         wxPyEndAllowThreads(__tstate);
16381         if (PyErr_Occurred()) SWIG_fail;
16382     }
16383     {
16384         resultobj = SWIG_From_int((int)(result));
16385     }
16386     return resultobj;
16387     fail:
16388     return NULL;
16389 }
16390
16391
16392 static PyObject *_wrap_BookCtrlBase_SetPageText(PyObject *, PyObject *args, PyObject *kwargs) {
16393     PyObject *resultobj;
16394     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16395     size_t arg2 ;
16396     wxString *arg3 = 0 ;
16397     bool result;
16398     bool temp3 = false ;
16399     PyObject * obj0 = 0 ;
16400     PyObject * obj1 = 0 ;
16401     PyObject * obj2 = 0 ;
16402     char *kwnames[] = {
16403         (char *) "self",(char *) "n",(char *) "strText", NULL
16404     };
16405
16406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BookCtrlBase_SetPageText",kwnames,&obj0,&obj1,&obj2)) goto fail;
16407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16408     if (SWIG_arg_fail(1)) SWIG_fail;
16409     {
16410         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16411         if (SWIG_arg_fail(2)) SWIG_fail;
16412     }
16413     {
16414         arg3 = wxString_in_helper(obj2);
16415         if (arg3 == NULL) SWIG_fail;
16416         temp3 = true;
16417     }
16418     {
16419         PyThreadState* __tstate = wxPyBeginAllowThreads();
16420         result = (bool)(arg1)->SetPageText(arg2,(wxString const &)*arg3);
16421
16422         wxPyEndAllowThreads(__tstate);
16423         if (PyErr_Occurred()) SWIG_fail;
16424     }
16425     {
16426         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16427     }
16428     {
16429         if (temp3)
16430         delete arg3;
16431     }
16432     return resultobj;
16433     fail:
16434     {
16435         if (temp3)
16436         delete arg3;
16437     }
16438     return NULL;
16439 }
16440
16441
16442 static PyObject *_wrap_BookCtrlBase_GetPageText(PyObject *, PyObject *args, PyObject *kwargs) {
16443     PyObject *resultobj;
16444     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16445     size_t arg2 ;
16446     wxString result;
16447     PyObject * obj0 = 0 ;
16448     PyObject * obj1 = 0 ;
16449     char *kwnames[] = {
16450         (char *) "self",(char *) "n", NULL
16451     };
16452
16453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPageText",kwnames,&obj0,&obj1)) goto fail;
16454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16455     if (SWIG_arg_fail(1)) SWIG_fail;
16456     {
16457         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16458         if (SWIG_arg_fail(2)) SWIG_fail;
16459     }
16460     {
16461         PyThreadState* __tstate = wxPyBeginAllowThreads();
16462         result = ((wxBookCtrlBase const *)arg1)->GetPageText(arg2);
16463
16464         wxPyEndAllowThreads(__tstate);
16465         if (PyErr_Occurred()) SWIG_fail;
16466     }
16467     {
16468 #if wxUSE_UNICODE
16469         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16470 #else
16471         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16472 #endif
16473     }
16474     return resultobj;
16475     fail:
16476     return NULL;
16477 }
16478
16479
16480 static PyObject *_wrap_BookCtrlBase_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16481     PyObject *resultobj;
16482     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16483     wxImageList *arg2 = (wxImageList *) 0 ;
16484     PyObject * obj0 = 0 ;
16485     PyObject * obj1 = 0 ;
16486     char *kwnames[] = {
16487         (char *) "self",(char *) "imageList", NULL
16488     };
16489
16490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetImageList",kwnames,&obj0,&obj1)) goto fail;
16491     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16492     if (SWIG_arg_fail(1)) SWIG_fail;
16493     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
16494     if (SWIG_arg_fail(2)) SWIG_fail;
16495     {
16496         PyThreadState* __tstate = wxPyBeginAllowThreads();
16497         (arg1)->SetImageList(arg2);
16498
16499         wxPyEndAllowThreads(__tstate);
16500         if (PyErr_Occurred()) SWIG_fail;
16501     }
16502     Py_INCREF(Py_None); resultobj = Py_None;
16503     return resultobj;
16504     fail:
16505     return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_BookCtrlBase_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16510     PyObject *resultobj;
16511     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16512     wxImageList *arg2 = (wxImageList *) 0 ;
16513     PyObject * obj0 = 0 ;
16514     PyObject * obj1 = 0 ;
16515     char *kwnames[] = {
16516         (char *) "self",(char *) "imageList", NULL
16517     };
16518
16519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_AssignImageList",kwnames,&obj0,&obj1)) goto fail;
16520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16521     if (SWIG_arg_fail(1)) SWIG_fail;
16522     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16523     if (SWIG_arg_fail(2)) SWIG_fail;
16524     {
16525         PyThreadState* __tstate = wxPyBeginAllowThreads();
16526         (arg1)->AssignImageList(arg2);
16527
16528         wxPyEndAllowThreads(__tstate);
16529         if (PyErr_Occurred()) SWIG_fail;
16530     }
16531     Py_INCREF(Py_None); resultobj = Py_None;
16532     return resultobj;
16533     fail:
16534     return NULL;
16535 }
16536
16537
16538 static PyObject *_wrap_BookCtrlBase_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16539     PyObject *resultobj;
16540     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16541     wxImageList *result;
16542     PyObject * obj0 = 0 ;
16543     char *kwnames[] = {
16544         (char *) "self", NULL
16545     };
16546
16547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetImageList",kwnames,&obj0)) goto fail;
16548     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16549     if (SWIG_arg_fail(1)) SWIG_fail;
16550     {
16551         PyThreadState* __tstate = wxPyBeginAllowThreads();
16552         result = (wxImageList *)((wxBookCtrlBase const *)arg1)->GetImageList();
16553
16554         wxPyEndAllowThreads(__tstate);
16555         if (PyErr_Occurred()) SWIG_fail;
16556     }
16557     {
16558         resultobj = wxPyMake_wxObject(result, 0);
16559     }
16560     return resultobj;
16561     fail:
16562     return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_BookCtrlBase_GetPageImage(PyObject *, PyObject *args, PyObject *kwargs) {
16567     PyObject *resultobj;
16568     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16569     size_t arg2 ;
16570     int result;
16571     PyObject * obj0 = 0 ;
16572     PyObject * obj1 = 0 ;
16573     char *kwnames[] = {
16574         (char *) "self",(char *) "n", NULL
16575     };
16576
16577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPageImage",kwnames,&obj0,&obj1)) goto fail;
16578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16579     if (SWIG_arg_fail(1)) SWIG_fail;
16580     {
16581         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16582         if (SWIG_arg_fail(2)) SWIG_fail;
16583     }
16584     {
16585         PyThreadState* __tstate = wxPyBeginAllowThreads();
16586         result = (int)((wxBookCtrlBase const *)arg1)->GetPageImage(arg2);
16587
16588         wxPyEndAllowThreads(__tstate);
16589         if (PyErr_Occurred()) SWIG_fail;
16590     }
16591     {
16592         resultobj = SWIG_From_int((int)(result));
16593     }
16594     return resultobj;
16595     fail:
16596     return NULL;
16597 }
16598
16599
16600 static PyObject *_wrap_BookCtrlBase_SetPageImage(PyObject *, PyObject *args, PyObject *kwargs) {
16601     PyObject *resultobj;
16602     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16603     size_t arg2 ;
16604     int arg3 ;
16605     bool result;
16606     PyObject * obj0 = 0 ;
16607     PyObject * obj1 = 0 ;
16608     PyObject * obj2 = 0 ;
16609     char *kwnames[] = {
16610         (char *) "self",(char *) "n",(char *) "imageId", NULL
16611     };
16612
16613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BookCtrlBase_SetPageImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
16614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16615     if (SWIG_arg_fail(1)) SWIG_fail;
16616     {
16617         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16618         if (SWIG_arg_fail(2)) SWIG_fail;
16619     }
16620     {
16621         arg3 = (int)(SWIG_As_int(obj2));
16622         if (SWIG_arg_fail(3)) SWIG_fail;
16623     }
16624     {
16625         PyThreadState* __tstate = wxPyBeginAllowThreads();
16626         result = (bool)(arg1)->SetPageImage(arg2,arg3);
16627
16628         wxPyEndAllowThreads(__tstate);
16629         if (PyErr_Occurred()) SWIG_fail;
16630     }
16631     {
16632         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16633     }
16634     return resultobj;
16635     fail:
16636     return NULL;
16637 }
16638
16639
16640 static PyObject *_wrap_BookCtrlBase_SetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
16641     PyObject *resultobj;
16642     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16643     wxSize *arg2 = 0 ;
16644     wxSize temp2 ;
16645     PyObject * obj0 = 0 ;
16646     PyObject * obj1 = 0 ;
16647     char *kwnames[] = {
16648         (char *) "self",(char *) "size", NULL
16649     };
16650
16651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetPageSize",kwnames,&obj0,&obj1)) goto fail;
16652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16653     if (SWIG_arg_fail(1)) SWIG_fail;
16654     {
16655         arg2 = &temp2;
16656         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16657     }
16658     {
16659         PyThreadState* __tstate = wxPyBeginAllowThreads();
16660         (arg1)->SetPageSize((wxSize const &)*arg2);
16661
16662         wxPyEndAllowThreads(__tstate);
16663         if (PyErr_Occurred()) SWIG_fail;
16664     }
16665     Py_INCREF(Py_None); resultobj = Py_None;
16666     return resultobj;
16667     fail:
16668     return NULL;
16669 }
16670
16671
16672 static PyObject *_wrap_BookCtrlBase_CalcSizeFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
16673     PyObject *resultobj;
16674     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16675     wxSize *arg2 = 0 ;
16676     wxSize result;
16677     wxSize temp2 ;
16678     PyObject * obj0 = 0 ;
16679     PyObject * obj1 = 0 ;
16680     char *kwnames[] = {
16681         (char *) "self",(char *) "sizePage", NULL
16682     };
16683
16684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_CalcSizeFromPage",kwnames,&obj0,&obj1)) goto fail;
16685     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16686     if (SWIG_arg_fail(1)) SWIG_fail;
16687     {
16688         arg2 = &temp2;
16689         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16690     }
16691     {
16692         PyThreadState* __tstate = wxPyBeginAllowThreads();
16693         result = ((wxBookCtrlBase const *)arg1)->CalcSizeFromPage((wxSize const &)*arg2);
16694
16695         wxPyEndAllowThreads(__tstate);
16696         if (PyErr_Occurred()) SWIG_fail;
16697     }
16698     {
16699         wxSize * resultptr;
16700         resultptr = new wxSize((wxSize &)(result));
16701         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16702     }
16703     return resultobj;
16704     fail:
16705     return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_BookCtrlBase_DeletePage(PyObject *, PyObject *args, PyObject *kwargs) {
16710     PyObject *resultobj;
16711     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16712     size_t arg2 ;
16713     bool result;
16714     PyObject * obj0 = 0 ;
16715     PyObject * obj1 = 0 ;
16716     char *kwnames[] = {
16717         (char *) "self",(char *) "n", NULL
16718     };
16719
16720     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_DeletePage",kwnames,&obj0,&obj1)) goto fail;
16721     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16722     if (SWIG_arg_fail(1)) SWIG_fail;
16723     {
16724         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16725         if (SWIG_arg_fail(2)) SWIG_fail;
16726     }
16727     {
16728         PyThreadState* __tstate = wxPyBeginAllowThreads();
16729         result = (bool)(arg1)->DeletePage(arg2);
16730
16731         wxPyEndAllowThreads(__tstate);
16732         if (PyErr_Occurred()) SWIG_fail;
16733     }
16734     {
16735         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16736     }
16737     return resultobj;
16738     fail:
16739     return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_BookCtrlBase_RemovePage(PyObject *, PyObject *args, PyObject *kwargs) {
16744     PyObject *resultobj;
16745     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16746     size_t arg2 ;
16747     bool result;
16748     PyObject * obj0 = 0 ;
16749     PyObject * obj1 = 0 ;
16750     char *kwnames[] = {
16751         (char *) "self",(char *) "n", NULL
16752     };
16753
16754     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_RemovePage",kwnames,&obj0,&obj1)) goto fail;
16755     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16756     if (SWIG_arg_fail(1)) SWIG_fail;
16757     {
16758         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16759         if (SWIG_arg_fail(2)) SWIG_fail;
16760     }
16761     {
16762         PyThreadState* __tstate = wxPyBeginAllowThreads();
16763         result = (bool)(arg1)->RemovePage(arg2);
16764
16765         wxPyEndAllowThreads(__tstate);
16766         if (PyErr_Occurred()) SWIG_fail;
16767     }
16768     {
16769         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16770     }
16771     return resultobj;
16772     fail:
16773     return NULL;
16774 }
16775
16776
16777 static PyObject *_wrap_BookCtrlBase_DeleteAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
16778     PyObject *resultobj;
16779     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16780     bool result;
16781     PyObject * obj0 = 0 ;
16782     char *kwnames[] = {
16783         (char *) "self", NULL
16784     };
16785
16786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_DeleteAllPages",kwnames,&obj0)) goto fail;
16787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16788     if (SWIG_arg_fail(1)) SWIG_fail;
16789     {
16790         PyThreadState* __tstate = wxPyBeginAllowThreads();
16791         result = (bool)(arg1)->DeleteAllPages();
16792
16793         wxPyEndAllowThreads(__tstate);
16794         if (PyErr_Occurred()) SWIG_fail;
16795     }
16796     {
16797         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16798     }
16799     return resultobj;
16800     fail:
16801     return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_BookCtrlBase_AddPage(PyObject *, PyObject *args, PyObject *kwargs) {
16806     PyObject *resultobj;
16807     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16808     wxWindow *arg2 = (wxWindow *) 0 ;
16809     wxString *arg3 = 0 ;
16810     bool arg4 = (bool) false ;
16811     int arg5 = (int) -1 ;
16812     bool result;
16813     bool temp3 = false ;
16814     PyObject * obj0 = 0 ;
16815     PyObject * obj1 = 0 ;
16816     PyObject * obj2 = 0 ;
16817     PyObject * obj3 = 0 ;
16818     PyObject * obj4 = 0 ;
16819     char *kwnames[] = {
16820         (char *) "self",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL
16821     };
16822
16823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:BookCtrlBase_AddPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16825     if (SWIG_arg_fail(1)) SWIG_fail;
16826     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16827     if (SWIG_arg_fail(2)) SWIG_fail;
16828     {
16829         arg3 = wxString_in_helper(obj2);
16830         if (arg3 == NULL) SWIG_fail;
16831         temp3 = true;
16832     }
16833     if (obj3) {
16834         {
16835             arg4 = (bool)(SWIG_As_bool(obj3));
16836             if (SWIG_arg_fail(4)) SWIG_fail;
16837         }
16838     }
16839     if (obj4) {
16840         {
16841             arg5 = (int)(SWIG_As_int(obj4));
16842             if (SWIG_arg_fail(5)) SWIG_fail;
16843         }
16844     }
16845     {
16846         PyThreadState* __tstate = wxPyBeginAllowThreads();
16847         result = (bool)(arg1)->AddPage(arg2,(wxString const &)*arg3,arg4,arg5);
16848
16849         wxPyEndAllowThreads(__tstate);
16850         if (PyErr_Occurred()) SWIG_fail;
16851     }
16852     {
16853         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854     }
16855     {
16856         if (temp3)
16857         delete arg3;
16858     }
16859     return resultobj;
16860     fail:
16861     {
16862         if (temp3)
16863         delete arg3;
16864     }
16865     return NULL;
16866 }
16867
16868
16869 static PyObject *_wrap_BookCtrlBase_InsertPage(PyObject *, PyObject *args, PyObject *kwargs) {
16870     PyObject *resultobj;
16871     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16872     size_t arg2 ;
16873     wxWindow *arg3 = (wxWindow *) 0 ;
16874     wxString *arg4 = 0 ;
16875     bool arg5 = (bool) false ;
16876     int arg6 = (int) -1 ;
16877     bool result;
16878     bool temp4 = false ;
16879     PyObject * obj0 = 0 ;
16880     PyObject * obj1 = 0 ;
16881     PyObject * obj2 = 0 ;
16882     PyObject * obj3 = 0 ;
16883     PyObject * obj4 = 0 ;
16884     PyObject * obj5 = 0 ;
16885     char *kwnames[] = {
16886         (char *) "self",(char *) "n",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL
16887     };
16888
16889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:BookCtrlBase_InsertPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
16890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16891     if (SWIG_arg_fail(1)) SWIG_fail;
16892     {
16893         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16894         if (SWIG_arg_fail(2)) SWIG_fail;
16895     }
16896     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16897     if (SWIG_arg_fail(3)) SWIG_fail;
16898     {
16899         arg4 = wxString_in_helper(obj3);
16900         if (arg4 == NULL) SWIG_fail;
16901         temp4 = true;
16902     }
16903     if (obj4) {
16904         {
16905             arg5 = (bool)(SWIG_As_bool(obj4));
16906             if (SWIG_arg_fail(5)) SWIG_fail;
16907         }
16908     }
16909     if (obj5) {
16910         {
16911             arg6 = (int)(SWIG_As_int(obj5));
16912             if (SWIG_arg_fail(6)) SWIG_fail;
16913         }
16914     }
16915     {
16916         PyThreadState* __tstate = wxPyBeginAllowThreads();
16917         result = (bool)(arg1)->InsertPage(arg2,arg3,(wxString const &)*arg4,arg5,arg6);
16918
16919         wxPyEndAllowThreads(__tstate);
16920         if (PyErr_Occurred()) SWIG_fail;
16921     }
16922     {
16923         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16924     }
16925     {
16926         if (temp4)
16927         delete arg4;
16928     }
16929     return resultobj;
16930     fail:
16931     {
16932         if (temp4)
16933         delete arg4;
16934     }
16935     return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_BookCtrlBase_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16940     PyObject *resultobj;
16941     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16942     size_t arg2 ;
16943     int result;
16944     PyObject * obj0 = 0 ;
16945     PyObject * obj1 = 0 ;
16946     char *kwnames[] = {
16947         (char *) "self",(char *) "n", NULL
16948     };
16949
16950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetSelection",kwnames,&obj0,&obj1)) goto fail;
16951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16952     if (SWIG_arg_fail(1)) SWIG_fail;
16953     {
16954         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16955         if (SWIG_arg_fail(2)) SWIG_fail;
16956     }
16957     {
16958         PyThreadState* __tstate = wxPyBeginAllowThreads();
16959         result = (int)(arg1)->SetSelection(arg2);
16960
16961         wxPyEndAllowThreads(__tstate);
16962         if (PyErr_Occurred()) SWIG_fail;
16963     }
16964     {
16965         resultobj = SWIG_From_int((int)(result));
16966     }
16967     return resultobj;
16968     fail:
16969     return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_BookCtrlBase_AdvanceSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16974     PyObject *resultobj;
16975     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16976     bool arg2 = (bool) true ;
16977     PyObject * obj0 = 0 ;
16978     PyObject * obj1 = 0 ;
16979     char *kwnames[] = {
16980         (char *) "self",(char *) "forward", NULL
16981     };
16982
16983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:BookCtrlBase_AdvanceSelection",kwnames,&obj0,&obj1)) goto fail;
16984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16985     if (SWIG_arg_fail(1)) SWIG_fail;
16986     if (obj1) {
16987         {
16988             arg2 = (bool)(SWIG_As_bool(obj1));
16989             if (SWIG_arg_fail(2)) SWIG_fail;
16990         }
16991     }
16992     {
16993         PyThreadState* __tstate = wxPyBeginAllowThreads();
16994         (arg1)->AdvanceSelection(arg2);
16995
16996         wxPyEndAllowThreads(__tstate);
16997         if (PyErr_Occurred()) SWIG_fail;
16998     }
16999     Py_INCREF(Py_None); resultobj = Py_None;
17000     return resultobj;
17001     fail:
17002     return NULL;
17003 }
17004
17005
17006 static PyObject *_wrap_BookCtrlBase_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
17007     PyObject *resultobj;
17008     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
17009     wxVisualAttributes result;
17010     PyObject * obj0 = 0 ;
17011     char *kwnames[] = {
17012         (char *) "variant", NULL
17013     };
17014
17015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BookCtrlBase_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
17016     if (obj0) {
17017         {
17018             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
17019             if (SWIG_arg_fail(1)) SWIG_fail;
17020         }
17021     }
17022     {
17023         if (!wxPyCheckForApp()) SWIG_fail;
17024         PyThreadState* __tstate = wxPyBeginAllowThreads();
17025         result = wxBookCtrlBase::GetClassDefaultAttributes((wxWindowVariant )arg1);
17026
17027         wxPyEndAllowThreads(__tstate);
17028         if (PyErr_Occurred()) SWIG_fail;
17029     }
17030     {
17031         wxVisualAttributes * resultptr;
17032         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
17033         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
17034     }
17035     return resultobj;
17036     fail:
17037     return NULL;
17038 }
17039
17040
17041 static PyObject * BookCtrlBase_swigregister(PyObject *, PyObject *args) {
17042     PyObject *obj;
17043     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17044     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlBase, obj);
17045     Py_INCREF(obj);
17046     return Py_BuildValue((char *)"");
17047 }
17048 static PyObject *_wrap_new_BookCtrlBaseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17049     PyObject *resultobj;
17050     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17051     int arg2 = (int) 0 ;
17052     int arg3 = (int) -1 ;
17053     int arg4 = (int) -1 ;
17054     wxBookCtrlBaseEvent *result;
17055     PyObject * obj0 = 0 ;
17056     PyObject * obj1 = 0 ;
17057     PyObject * obj2 = 0 ;
17058     PyObject * obj3 = 0 ;
17059     char *kwnames[] = {
17060         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17061     };
17062
17063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_BookCtrlBaseEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17064     if (obj0) {
17065         {
17066             arg1 = (wxEventType)(SWIG_As_int(obj0));
17067             if (SWIG_arg_fail(1)) SWIG_fail;
17068         }
17069     }
17070     if (obj1) {
17071         {
17072             arg2 = (int)(SWIG_As_int(obj1));
17073             if (SWIG_arg_fail(2)) SWIG_fail;
17074         }
17075     }
17076     if (obj2) {
17077         {
17078             arg3 = (int)(SWIG_As_int(obj2));
17079             if (SWIG_arg_fail(3)) SWIG_fail;
17080         }
17081     }
17082     if (obj3) {
17083         {
17084             arg4 = (int)(SWIG_As_int(obj3));
17085             if (SWIG_arg_fail(4)) SWIG_fail;
17086         }
17087     }
17088     {
17089         PyThreadState* __tstate = wxPyBeginAllowThreads();
17090         result = (wxBookCtrlBaseEvent *)new wxBookCtrlBaseEvent(arg1,arg2,arg3,arg4);
17091
17092         wxPyEndAllowThreads(__tstate);
17093         if (PyErr_Occurred()) SWIG_fail;
17094     }
17095     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlBaseEvent, 1);
17096     return resultobj;
17097     fail:
17098     return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_BookCtrlBaseEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17103     PyObject *resultobj;
17104     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17105     int result;
17106     PyObject * obj0 = 0 ;
17107     char *kwnames[] = {
17108         (char *) "self", NULL
17109     };
17110
17111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBaseEvent_GetSelection",kwnames,&obj0)) goto fail;
17112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17113     if (SWIG_arg_fail(1)) SWIG_fail;
17114     {
17115         PyThreadState* __tstate = wxPyBeginAllowThreads();
17116         result = (int)((wxBookCtrlBaseEvent const *)arg1)->GetSelection();
17117
17118         wxPyEndAllowThreads(__tstate);
17119         if (PyErr_Occurred()) SWIG_fail;
17120     }
17121     {
17122         resultobj = SWIG_From_int((int)(result));
17123     }
17124     return resultobj;
17125     fail:
17126     return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_BookCtrlBaseEvent_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17131     PyObject *resultobj;
17132     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17133     int arg2 ;
17134     PyObject * obj0 = 0 ;
17135     PyObject * obj1 = 0 ;
17136     char *kwnames[] = {
17137         (char *) "self",(char *) "nSel", NULL
17138     };
17139
17140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBaseEvent_SetSelection",kwnames,&obj0,&obj1)) goto fail;
17141     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17142     if (SWIG_arg_fail(1)) SWIG_fail;
17143     {
17144         arg2 = (int)(SWIG_As_int(obj1));
17145         if (SWIG_arg_fail(2)) SWIG_fail;
17146     }
17147     {
17148         PyThreadState* __tstate = wxPyBeginAllowThreads();
17149         (arg1)->SetSelection(arg2);
17150
17151         wxPyEndAllowThreads(__tstate);
17152         if (PyErr_Occurred()) SWIG_fail;
17153     }
17154     Py_INCREF(Py_None); resultobj = Py_None;
17155     return resultobj;
17156     fail:
17157     return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_BookCtrlBaseEvent_GetOldSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17162     PyObject *resultobj;
17163     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17164     int result;
17165     PyObject * obj0 = 0 ;
17166     char *kwnames[] = {
17167         (char *) "self", NULL
17168     };
17169
17170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBaseEvent_GetOldSelection",kwnames,&obj0)) goto fail;
17171     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17172     if (SWIG_arg_fail(1)) SWIG_fail;
17173     {
17174         PyThreadState* __tstate = wxPyBeginAllowThreads();
17175         result = (int)((wxBookCtrlBaseEvent const *)arg1)->GetOldSelection();
17176
17177         wxPyEndAllowThreads(__tstate);
17178         if (PyErr_Occurred()) SWIG_fail;
17179     }
17180     {
17181         resultobj = SWIG_From_int((int)(result));
17182     }
17183     return resultobj;
17184     fail:
17185     return NULL;
17186 }
17187
17188
17189 static PyObject *_wrap_BookCtrlBaseEvent_SetOldSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17190     PyObject *resultobj;
17191     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17192     int arg2 ;
17193     PyObject * obj0 = 0 ;
17194     PyObject * obj1 = 0 ;
17195     char *kwnames[] = {
17196         (char *) "self",(char *) "nOldSel", NULL
17197     };
17198
17199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBaseEvent_SetOldSelection",kwnames,&obj0,&obj1)) goto fail;
17200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17201     if (SWIG_arg_fail(1)) SWIG_fail;
17202     {
17203         arg2 = (int)(SWIG_As_int(obj1));
17204         if (SWIG_arg_fail(2)) SWIG_fail;
17205     }
17206     {
17207         PyThreadState* __tstate = wxPyBeginAllowThreads();
17208         (arg1)->SetOldSelection(arg2);
17209
17210         wxPyEndAllowThreads(__tstate);
17211         if (PyErr_Occurred()) SWIG_fail;
17212     }
17213     Py_INCREF(Py_None); resultobj = Py_None;
17214     return resultobj;
17215     fail:
17216     return NULL;
17217 }
17218
17219
17220 static PyObject * BookCtrlBaseEvent_swigregister(PyObject *, PyObject *args) {
17221     PyObject *obj;
17222     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17223     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlBaseEvent, obj);
17224     Py_INCREF(obj);
17225     return Py_BuildValue((char *)"");
17226 }
17227 static PyObject *_wrap_new_Notebook(PyObject *, PyObject *args, PyObject *kwargs) {
17228     PyObject *resultobj;
17229     wxWindow *arg1 = (wxWindow *) 0 ;
17230     int arg2 = (int) -1 ;
17231     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17232     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17233     wxSize const &arg4_defvalue = wxDefaultSize ;
17234     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17235     long arg5 = (long) 0 ;
17236     wxString const &arg6_defvalue = wxPyNOTEBOOK_NAME ;
17237     wxString *arg6 = (wxString *) &arg6_defvalue ;
17238     wxNotebook *result;
17239     wxPoint temp3 ;
17240     wxSize temp4 ;
17241     bool temp6 = false ;
17242     PyObject * obj0 = 0 ;
17243     PyObject * obj1 = 0 ;
17244     PyObject * obj2 = 0 ;
17245     PyObject * obj3 = 0 ;
17246     PyObject * obj4 = 0 ;
17247     PyObject * obj5 = 0 ;
17248     char *kwnames[] = {
17249         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17250     };
17251
17252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Notebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17253     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17254     if (SWIG_arg_fail(1)) SWIG_fail;
17255     if (obj1) {
17256         {
17257             arg2 = (int)(SWIG_As_int(obj1));
17258             if (SWIG_arg_fail(2)) SWIG_fail;
17259         }
17260     }
17261     if (obj2) {
17262         {
17263             arg3 = &temp3;
17264             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17265         }
17266     }
17267     if (obj3) {
17268         {
17269             arg4 = &temp4;
17270             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17271         }
17272     }
17273     if (obj4) {
17274         {
17275             arg5 = (long)(SWIG_As_long(obj4));
17276             if (SWIG_arg_fail(5)) SWIG_fail;
17277         }
17278     }
17279     if (obj5) {
17280         {
17281             arg6 = wxString_in_helper(obj5);
17282             if (arg6 == NULL) SWIG_fail;
17283             temp6 = true;
17284         }
17285     }
17286     {
17287         if (!wxPyCheckForApp()) SWIG_fail;
17288         PyThreadState* __tstate = wxPyBeginAllowThreads();
17289         result = (wxNotebook *)new wxNotebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17290
17291         wxPyEndAllowThreads(__tstate);
17292         if (PyErr_Occurred()) SWIG_fail;
17293     }
17294     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebook, 1);
17295     {
17296         if (temp6)
17297         delete arg6;
17298     }
17299     return resultobj;
17300     fail:
17301     {
17302         if (temp6)
17303         delete arg6;
17304     }
17305     return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_new_PreNotebook(PyObject *, PyObject *args, PyObject *kwargs) {
17310     PyObject *resultobj;
17311     wxNotebook *result;
17312     char *kwnames[] = {
17313         NULL
17314     };
17315
17316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreNotebook",kwnames)) goto fail;
17317     {
17318         if (!wxPyCheckForApp()) SWIG_fail;
17319         PyThreadState* __tstate = wxPyBeginAllowThreads();
17320         result = (wxNotebook *)new wxNotebook();
17321
17322         wxPyEndAllowThreads(__tstate);
17323         if (PyErr_Occurred()) SWIG_fail;
17324     }
17325     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebook, 1);
17326     return resultobj;
17327     fail:
17328     return NULL;
17329 }
17330
17331
17332 static PyObject *_wrap_Notebook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17333     PyObject *resultobj;
17334     wxNotebook *arg1 = (wxNotebook *) 0 ;
17335     wxWindow *arg2 = (wxWindow *) 0 ;
17336     int arg3 = (int) -1 ;
17337     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17338     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17339     wxSize const &arg5_defvalue = wxDefaultSize ;
17340     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17341     long arg6 = (long) 0 ;
17342     wxString const &arg7_defvalue = wxPyNOTEBOOK_NAME ;
17343     wxString *arg7 = (wxString *) &arg7_defvalue ;
17344     bool result;
17345     wxPoint temp4 ;
17346     wxSize temp5 ;
17347     bool temp7 = false ;
17348     PyObject * obj0 = 0 ;
17349     PyObject * obj1 = 0 ;
17350     PyObject * obj2 = 0 ;
17351     PyObject * obj3 = 0 ;
17352     PyObject * obj4 = 0 ;
17353     PyObject * obj5 = 0 ;
17354     PyObject * obj6 = 0 ;
17355     char *kwnames[] = {
17356         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17357     };
17358
17359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Notebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17360     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17361     if (SWIG_arg_fail(1)) SWIG_fail;
17362     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17363     if (SWIG_arg_fail(2)) SWIG_fail;
17364     if (obj2) {
17365         {
17366             arg3 = (int)(SWIG_As_int(obj2));
17367             if (SWIG_arg_fail(3)) SWIG_fail;
17368         }
17369     }
17370     if (obj3) {
17371         {
17372             arg4 = &temp4;
17373             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17374         }
17375     }
17376     if (obj4) {
17377         {
17378             arg5 = &temp5;
17379             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17380         }
17381     }
17382     if (obj5) {
17383         {
17384             arg6 = (long)(SWIG_As_long(obj5));
17385             if (SWIG_arg_fail(6)) SWIG_fail;
17386         }
17387     }
17388     if (obj6) {
17389         {
17390             arg7 = wxString_in_helper(obj6);
17391             if (arg7 == NULL) SWIG_fail;
17392             temp7 = true;
17393         }
17394     }
17395     {
17396         PyThreadState* __tstate = wxPyBeginAllowThreads();
17397         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17398
17399         wxPyEndAllowThreads(__tstate);
17400         if (PyErr_Occurred()) SWIG_fail;
17401     }
17402     {
17403         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17404     }
17405     {
17406         if (temp7)
17407         delete arg7;
17408     }
17409     return resultobj;
17410     fail:
17411     {
17412         if (temp7)
17413         delete arg7;
17414     }
17415     return NULL;
17416 }
17417
17418
17419 static PyObject *_wrap_Notebook_GetRowCount(PyObject *, PyObject *args, PyObject *kwargs) {
17420     PyObject *resultobj;
17421     wxNotebook *arg1 = (wxNotebook *) 0 ;
17422     int result;
17423     PyObject * obj0 = 0 ;
17424     char *kwnames[] = {
17425         (char *) "self", NULL
17426     };
17427
17428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Notebook_GetRowCount",kwnames,&obj0)) goto fail;
17429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17430     if (SWIG_arg_fail(1)) SWIG_fail;
17431     {
17432         PyThreadState* __tstate = wxPyBeginAllowThreads();
17433         result = (int)((wxNotebook const *)arg1)->GetRowCount();
17434
17435         wxPyEndAllowThreads(__tstate);
17436         if (PyErr_Occurred()) SWIG_fail;
17437     }
17438     {
17439         resultobj = SWIG_From_int((int)(result));
17440     }
17441     return resultobj;
17442     fail:
17443     return NULL;
17444 }
17445
17446
17447 static PyObject *_wrap_Notebook_SetPadding(PyObject *, PyObject *args, PyObject *kwargs) {
17448     PyObject *resultobj;
17449     wxNotebook *arg1 = (wxNotebook *) 0 ;
17450     wxSize *arg2 = 0 ;
17451     wxSize temp2 ;
17452     PyObject * obj0 = 0 ;
17453     PyObject * obj1 = 0 ;
17454     char *kwnames[] = {
17455         (char *) "self",(char *) "padding", NULL
17456     };
17457
17458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetPadding",kwnames,&obj0,&obj1)) goto fail;
17459     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17460     if (SWIG_arg_fail(1)) SWIG_fail;
17461     {
17462         arg2 = &temp2;
17463         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17464     }
17465     {
17466         PyThreadState* __tstate = wxPyBeginAllowThreads();
17467         (arg1)->SetPadding((wxSize const &)*arg2);
17468
17469         wxPyEndAllowThreads(__tstate);
17470         if (PyErr_Occurred()) SWIG_fail;
17471     }
17472     Py_INCREF(Py_None); resultobj = Py_None;
17473     return resultobj;
17474     fail:
17475     return NULL;
17476 }
17477
17478
17479 static PyObject *_wrap_Notebook_SetTabSize(PyObject *, PyObject *args, PyObject *kwargs) {
17480     PyObject *resultobj;
17481     wxNotebook *arg1 = (wxNotebook *) 0 ;
17482     wxSize *arg2 = 0 ;
17483     wxSize temp2 ;
17484     PyObject * obj0 = 0 ;
17485     PyObject * obj1 = 0 ;
17486     char *kwnames[] = {
17487         (char *) "self",(char *) "sz", NULL
17488     };
17489
17490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetTabSize",kwnames,&obj0,&obj1)) goto fail;
17491     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17492     if (SWIG_arg_fail(1)) SWIG_fail;
17493     {
17494         arg2 = &temp2;
17495         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17496     }
17497     {
17498         PyThreadState* __tstate = wxPyBeginAllowThreads();
17499         (arg1)->SetTabSize((wxSize const &)*arg2);
17500
17501         wxPyEndAllowThreads(__tstate);
17502         if (PyErr_Occurred()) SWIG_fail;
17503     }
17504     Py_INCREF(Py_None); resultobj = Py_None;
17505     return resultobj;
17506     fail:
17507     return NULL;
17508 }
17509
17510
17511 static PyObject *_wrap_Notebook_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
17512     PyObject *resultobj;
17513     wxNotebook *arg1 = (wxNotebook *) 0 ;
17514     wxPoint *arg2 = 0 ;
17515     long *arg3 = (long *) 0 ;
17516     int result;
17517     wxPoint temp2 ;
17518     long temp3 ;
17519     int res3 = 0 ;
17520     PyObject * obj0 = 0 ;
17521     PyObject * obj1 = 0 ;
17522     char *kwnames[] = {
17523         (char *) "self",(char *) "pt", NULL
17524     };
17525
17526     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_HitTest",kwnames,&obj0,&obj1)) goto fail;
17528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17529     if (SWIG_arg_fail(1)) SWIG_fail;
17530     {
17531         arg2 = &temp2;
17532         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17533     }
17534     {
17535         PyThreadState* __tstate = wxPyBeginAllowThreads();
17536         result = (int)((wxNotebook const *)arg1)->HitTest((wxPoint const &)*arg2,arg3);
17537
17538         wxPyEndAllowThreads(__tstate);
17539         if (PyErr_Occurred()) SWIG_fail;
17540     }
17541     {
17542         resultobj = SWIG_From_int((int)(result));
17543     }
17544     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17545     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17546     return resultobj;
17547     fail:
17548     return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_Notebook_CalcSizeFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
17553     PyObject *resultobj;
17554     wxNotebook *arg1 = (wxNotebook *) 0 ;
17555     wxSize *arg2 = 0 ;
17556     wxSize result;
17557     wxSize temp2 ;
17558     PyObject * obj0 = 0 ;
17559     PyObject * obj1 = 0 ;
17560     char *kwnames[] = {
17561         (char *) "self",(char *) "sizePage", NULL
17562     };
17563
17564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_CalcSizeFromPage",kwnames,&obj0,&obj1)) goto fail;
17565     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17566     if (SWIG_arg_fail(1)) SWIG_fail;
17567     {
17568         arg2 = &temp2;
17569         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17570     }
17571     {
17572         PyThreadState* __tstate = wxPyBeginAllowThreads();
17573         result = ((wxNotebook const *)arg1)->CalcSizeFromPage((wxSize const &)*arg2);
17574
17575         wxPyEndAllowThreads(__tstate);
17576         if (PyErr_Occurred()) SWIG_fail;
17577     }
17578     {
17579         wxSize * resultptr;
17580         resultptr = new wxSize((wxSize &)(result));
17581         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17582     }
17583     return resultobj;
17584     fail:
17585     return NULL;
17586 }
17587
17588
17589 static PyObject *_wrap_Notebook_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
17590     PyObject *resultobj;
17591     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
17592     wxVisualAttributes result;
17593     PyObject * obj0 = 0 ;
17594     char *kwnames[] = {
17595         (char *) "variant", NULL
17596     };
17597
17598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Notebook_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
17599     if (obj0) {
17600         {
17601             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
17602             if (SWIG_arg_fail(1)) SWIG_fail;
17603         }
17604     }
17605     {
17606         if (!wxPyCheckForApp()) SWIG_fail;
17607         PyThreadState* __tstate = wxPyBeginAllowThreads();
17608         result = wxNotebook::GetClassDefaultAttributes((wxWindowVariant )arg1);
17609
17610         wxPyEndAllowThreads(__tstate);
17611         if (PyErr_Occurred()) SWIG_fail;
17612     }
17613     {
17614         wxVisualAttributes * resultptr;
17615         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
17616         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
17617     }
17618     return resultobj;
17619     fail:
17620     return NULL;
17621 }
17622
17623
17624 static PyObject * Notebook_swigregister(PyObject *, PyObject *args) {
17625     PyObject *obj;
17626     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17627     SWIG_TypeClientData(SWIGTYPE_p_wxNotebook, obj);
17628     Py_INCREF(obj);
17629     return Py_BuildValue((char *)"");
17630 }
17631 static PyObject *_wrap_new_NotebookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17632     PyObject *resultobj;
17633     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17634     int arg2 = (int) 0 ;
17635     int arg3 = (int) -1 ;
17636     int arg4 = (int) -1 ;
17637     wxNotebookEvent *result;
17638     PyObject * obj0 = 0 ;
17639     PyObject * obj1 = 0 ;
17640     PyObject * obj2 = 0 ;
17641     PyObject * obj3 = 0 ;
17642     char *kwnames[] = {
17643         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17644     };
17645
17646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_NotebookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17647     if (obj0) {
17648         {
17649             arg1 = (wxEventType)(SWIG_As_int(obj0));
17650             if (SWIG_arg_fail(1)) SWIG_fail;
17651         }
17652     }
17653     if (obj1) {
17654         {
17655             arg2 = (int)(SWIG_As_int(obj1));
17656             if (SWIG_arg_fail(2)) SWIG_fail;
17657         }
17658     }
17659     if (obj2) {
17660         {
17661             arg3 = (int)(SWIG_As_int(obj2));
17662             if (SWIG_arg_fail(3)) SWIG_fail;
17663         }
17664     }
17665     if (obj3) {
17666         {
17667             arg4 = (int)(SWIG_As_int(obj3));
17668             if (SWIG_arg_fail(4)) SWIG_fail;
17669         }
17670     }
17671     {
17672         PyThreadState* __tstate = wxPyBeginAllowThreads();
17673         result = (wxNotebookEvent *)new wxNotebookEvent(arg1,arg2,arg3,arg4);
17674
17675         wxPyEndAllowThreads(__tstate);
17676         if (PyErr_Occurred()) SWIG_fail;
17677     }
17678     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebookEvent, 1);
17679     return resultobj;
17680     fail:
17681     return NULL;
17682 }
17683
17684
17685 static PyObject * NotebookEvent_swigregister(PyObject *, PyObject *args) {
17686     PyObject *obj;
17687     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17688     SWIG_TypeClientData(SWIGTYPE_p_wxNotebookEvent, obj);
17689     Py_INCREF(obj);
17690     return Py_BuildValue((char *)"");
17691 }
17692 static PyObject *_wrap_new_Listbook(PyObject *, PyObject *args, PyObject *kwargs) {
17693     PyObject *resultobj;
17694     wxWindow *arg1 = (wxWindow *) 0 ;
17695     int arg2 = (int) -1 ;
17696     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17697     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17698     wxSize const &arg4_defvalue = wxDefaultSize ;
17699     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17700     long arg5 = (long) 0 ;
17701     wxString const &arg6_defvalue = wxPyEmptyString ;
17702     wxString *arg6 = (wxString *) &arg6_defvalue ;
17703     wxListbook *result;
17704     wxPoint temp3 ;
17705     wxSize temp4 ;
17706     bool temp6 = false ;
17707     PyObject * obj0 = 0 ;
17708     PyObject * obj1 = 0 ;
17709     PyObject * obj2 = 0 ;
17710     PyObject * obj3 = 0 ;
17711     PyObject * obj4 = 0 ;
17712     PyObject * obj5 = 0 ;
17713     char *kwnames[] = {
17714         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17715     };
17716
17717     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Listbook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17718     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17719     if (SWIG_arg_fail(1)) SWIG_fail;
17720     if (obj1) {
17721         {
17722             arg2 = (int)(SWIG_As_int(obj1));
17723             if (SWIG_arg_fail(2)) SWIG_fail;
17724         }
17725     }
17726     if (obj2) {
17727         {
17728             arg3 = &temp3;
17729             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17730         }
17731     }
17732     if (obj3) {
17733         {
17734             arg4 = &temp4;
17735             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17736         }
17737     }
17738     if (obj4) {
17739         {
17740             arg5 = (long)(SWIG_As_long(obj4));
17741             if (SWIG_arg_fail(5)) SWIG_fail;
17742         }
17743     }
17744     if (obj5) {
17745         {
17746             arg6 = wxString_in_helper(obj5);
17747             if (arg6 == NULL) SWIG_fail;
17748             temp6 = true;
17749         }
17750     }
17751     {
17752         if (!wxPyCheckForApp()) SWIG_fail;
17753         PyThreadState* __tstate = wxPyBeginAllowThreads();
17754         result = (wxListbook *)new wxListbook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17755
17756         wxPyEndAllowThreads(__tstate);
17757         if (PyErr_Occurred()) SWIG_fail;
17758     }
17759     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbook, 1);
17760     {
17761         if (temp6)
17762         delete arg6;
17763     }
17764     return resultobj;
17765     fail:
17766     {
17767         if (temp6)
17768         delete arg6;
17769     }
17770     return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_new_PreListbook(PyObject *, PyObject *args, PyObject *kwargs) {
17775     PyObject *resultobj;
17776     wxListbook *result;
17777     char *kwnames[] = {
17778         NULL
17779     };
17780
17781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListbook",kwnames)) goto fail;
17782     {
17783         if (!wxPyCheckForApp()) SWIG_fail;
17784         PyThreadState* __tstate = wxPyBeginAllowThreads();
17785         result = (wxListbook *)new wxListbook();
17786
17787         wxPyEndAllowThreads(__tstate);
17788         if (PyErr_Occurred()) SWIG_fail;
17789     }
17790     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbook, 1);
17791     return resultobj;
17792     fail:
17793     return NULL;
17794 }
17795
17796
17797 static PyObject *_wrap_Listbook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17798     PyObject *resultobj;
17799     wxListbook *arg1 = (wxListbook *) 0 ;
17800     wxWindow *arg2 = (wxWindow *) 0 ;
17801     int arg3 = (int) -1 ;
17802     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17803     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17804     wxSize const &arg5_defvalue = wxDefaultSize ;
17805     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17806     long arg6 = (long) 0 ;
17807     wxString const &arg7_defvalue = wxPyEmptyString ;
17808     wxString *arg7 = (wxString *) &arg7_defvalue ;
17809     bool result;
17810     wxPoint temp4 ;
17811     wxSize temp5 ;
17812     bool temp7 = false ;
17813     PyObject * obj0 = 0 ;
17814     PyObject * obj1 = 0 ;
17815     PyObject * obj2 = 0 ;
17816     PyObject * obj3 = 0 ;
17817     PyObject * obj4 = 0 ;
17818     PyObject * obj5 = 0 ;
17819     PyObject * obj6 = 0 ;
17820     char *kwnames[] = {
17821         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17822     };
17823
17824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Listbook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17825     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17826     if (SWIG_arg_fail(1)) SWIG_fail;
17827     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17828     if (SWIG_arg_fail(2)) SWIG_fail;
17829     if (obj2) {
17830         {
17831             arg3 = (int)(SWIG_As_int(obj2));
17832             if (SWIG_arg_fail(3)) SWIG_fail;
17833         }
17834     }
17835     if (obj3) {
17836         {
17837             arg4 = &temp4;
17838             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17839         }
17840     }
17841     if (obj4) {
17842         {
17843             arg5 = &temp5;
17844             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17845         }
17846     }
17847     if (obj5) {
17848         {
17849             arg6 = (long)(SWIG_As_long(obj5));
17850             if (SWIG_arg_fail(6)) SWIG_fail;
17851         }
17852     }
17853     if (obj6) {
17854         {
17855             arg7 = wxString_in_helper(obj6);
17856             if (arg7 == NULL) SWIG_fail;
17857             temp7 = true;
17858         }
17859     }
17860     {
17861         PyThreadState* __tstate = wxPyBeginAllowThreads();
17862         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17863
17864         wxPyEndAllowThreads(__tstate);
17865         if (PyErr_Occurred()) SWIG_fail;
17866     }
17867     {
17868         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869     }
17870     {
17871         if (temp7)
17872         delete arg7;
17873     }
17874     return resultobj;
17875     fail:
17876     {
17877         if (temp7)
17878         delete arg7;
17879     }
17880     return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_Listbook_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
17885     PyObject *resultobj;
17886     wxListbook *arg1 = (wxListbook *) 0 ;
17887     bool result;
17888     PyObject * obj0 = 0 ;
17889     char *kwnames[] = {
17890         (char *) "self", NULL
17891     };
17892
17893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Listbook_IsVertical",kwnames,&obj0)) goto fail;
17894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17895     if (SWIG_arg_fail(1)) SWIG_fail;
17896     {
17897         PyThreadState* __tstate = wxPyBeginAllowThreads();
17898         result = (bool)((wxListbook const *)arg1)->IsVertical();
17899
17900         wxPyEndAllowThreads(__tstate);
17901         if (PyErr_Occurred()) SWIG_fail;
17902     }
17903     {
17904         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17905     }
17906     return resultobj;
17907     fail:
17908     return NULL;
17909 }
17910
17911
17912 static PyObject *_wrap_Listbook_GetListView(PyObject *, PyObject *args, PyObject *kwargs) {
17913     PyObject *resultobj;
17914     wxListbook *arg1 = (wxListbook *) 0 ;
17915     wxListView *result;
17916     PyObject * obj0 = 0 ;
17917     char *kwnames[] = {
17918         (char *) "self", NULL
17919     };
17920
17921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Listbook_GetListView",kwnames,&obj0)) goto fail;
17922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17923     if (SWIG_arg_fail(1)) SWIG_fail;
17924     {
17925         PyThreadState* __tstate = wxPyBeginAllowThreads();
17926         result = (wxListView *)(arg1)->GetListView();
17927
17928         wxPyEndAllowThreads(__tstate);
17929         if (PyErr_Occurred()) SWIG_fail;
17930     }
17931     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 0);
17932     return resultobj;
17933     fail:
17934     return NULL;
17935 }
17936
17937
17938 static PyObject * Listbook_swigregister(PyObject *, PyObject *args) {
17939     PyObject *obj;
17940     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17941     SWIG_TypeClientData(SWIGTYPE_p_wxListbook, obj);
17942     Py_INCREF(obj);
17943     return Py_BuildValue((char *)"");
17944 }
17945 static PyObject *_wrap_new_ListbookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17946     PyObject *resultobj;
17947     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17948     int arg2 = (int) 0 ;
17949     int arg3 = (int) -1 ;
17950     int arg4 = (int) -1 ;
17951     wxListbookEvent *result;
17952     PyObject * obj0 = 0 ;
17953     PyObject * obj1 = 0 ;
17954     PyObject * obj2 = 0 ;
17955     PyObject * obj3 = 0 ;
17956     char *kwnames[] = {
17957         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17958     };
17959
17960     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ListbookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17961     if (obj0) {
17962         {
17963             arg1 = (wxEventType)(SWIG_As_int(obj0));
17964             if (SWIG_arg_fail(1)) SWIG_fail;
17965         }
17966     }
17967     if (obj1) {
17968         {
17969             arg2 = (int)(SWIG_As_int(obj1));
17970             if (SWIG_arg_fail(2)) SWIG_fail;
17971         }
17972     }
17973     if (obj2) {
17974         {
17975             arg3 = (int)(SWIG_As_int(obj2));
17976             if (SWIG_arg_fail(3)) SWIG_fail;
17977         }
17978     }
17979     if (obj3) {
17980         {
17981             arg4 = (int)(SWIG_As_int(obj3));
17982             if (SWIG_arg_fail(4)) SWIG_fail;
17983         }
17984     }
17985     {
17986         PyThreadState* __tstate = wxPyBeginAllowThreads();
17987         result = (wxListbookEvent *)new wxListbookEvent(arg1,arg2,arg3,arg4);
17988
17989         wxPyEndAllowThreads(__tstate);
17990         if (PyErr_Occurred()) SWIG_fail;
17991     }
17992     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbookEvent, 1);
17993     return resultobj;
17994     fail:
17995     return NULL;
17996 }
17997
17998
17999 static PyObject * ListbookEvent_swigregister(PyObject *, PyObject *args) {
18000     PyObject *obj;
18001     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18002     SWIG_TypeClientData(SWIGTYPE_p_wxListbookEvent, obj);
18003     Py_INCREF(obj);
18004     return Py_BuildValue((char *)"");
18005 }
18006 static PyObject *_wrap_new_Choicebook(PyObject *, PyObject *args, PyObject *kwargs) {
18007     PyObject *resultobj;
18008     wxWindow *arg1 = (wxWindow *) 0 ;
18009     int arg2 ;
18010     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18011     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18012     wxSize const &arg4_defvalue = wxDefaultSize ;
18013     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18014     long arg5 = (long) 0 ;
18015     wxString const &arg6_defvalue = wxPyEmptyString ;
18016     wxString *arg6 = (wxString *) &arg6_defvalue ;
18017     wxChoicebook *result;
18018     wxPoint temp3 ;
18019     wxSize temp4 ;
18020     bool temp6 = false ;
18021     PyObject * obj0 = 0 ;
18022     PyObject * obj1 = 0 ;
18023     PyObject * obj2 = 0 ;
18024     PyObject * obj3 = 0 ;
18025     PyObject * obj4 = 0 ;
18026     PyObject * obj5 = 0 ;
18027     char *kwnames[] = {
18028         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18029     };
18030
18031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_Choicebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18032     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18033     if (SWIG_arg_fail(1)) SWIG_fail;
18034     {
18035         arg2 = (int)(SWIG_As_int(obj1));
18036         if (SWIG_arg_fail(2)) SWIG_fail;
18037     }
18038     if (obj2) {
18039         {
18040             arg3 = &temp3;
18041             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18042         }
18043     }
18044     if (obj3) {
18045         {
18046             arg4 = &temp4;
18047             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18048         }
18049     }
18050     if (obj4) {
18051         {
18052             arg5 = (long)(SWIG_As_long(obj4));
18053             if (SWIG_arg_fail(5)) SWIG_fail;
18054         }
18055     }
18056     if (obj5) {
18057         {
18058             arg6 = wxString_in_helper(obj5);
18059             if (arg6 == NULL) SWIG_fail;
18060             temp6 = true;
18061         }
18062     }
18063     {
18064         if (!wxPyCheckForApp()) SWIG_fail;
18065         PyThreadState* __tstate = wxPyBeginAllowThreads();
18066         result = (wxChoicebook *)new wxChoicebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18067
18068         wxPyEndAllowThreads(__tstate);
18069         if (PyErr_Occurred()) SWIG_fail;
18070     }
18071     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebook, 1);
18072     {
18073         if (temp6)
18074         delete arg6;
18075     }
18076     return resultobj;
18077     fail:
18078     {
18079         if (temp6)
18080         delete arg6;
18081     }
18082     return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_new_PreChoicebook(PyObject *, PyObject *args, PyObject *kwargs) {
18087     PyObject *resultobj;
18088     wxChoicebook *result;
18089     char *kwnames[] = {
18090         NULL
18091     };
18092
18093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreChoicebook",kwnames)) goto fail;
18094     {
18095         if (!wxPyCheckForApp()) SWIG_fail;
18096         PyThreadState* __tstate = wxPyBeginAllowThreads();
18097         result = (wxChoicebook *)new wxChoicebook();
18098
18099         wxPyEndAllowThreads(__tstate);
18100         if (PyErr_Occurred()) SWIG_fail;
18101     }
18102     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebook, 1);
18103     return resultobj;
18104     fail:
18105     return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_Choicebook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
18110     PyObject *resultobj;
18111     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18112     wxWindow *arg2 = (wxWindow *) 0 ;
18113     int arg3 ;
18114     wxPoint const &arg4_defvalue = wxDefaultPosition ;
18115     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
18116     wxSize const &arg5_defvalue = wxDefaultSize ;
18117     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
18118     long arg6 = (long) 0 ;
18119     wxString const &arg7_defvalue = wxPyEmptyString ;
18120     wxString *arg7 = (wxString *) &arg7_defvalue ;
18121     bool result;
18122     wxPoint temp4 ;
18123     wxSize temp5 ;
18124     bool temp7 = false ;
18125     PyObject * obj0 = 0 ;
18126     PyObject * obj1 = 0 ;
18127     PyObject * obj2 = 0 ;
18128     PyObject * obj3 = 0 ;
18129     PyObject * obj4 = 0 ;
18130     PyObject * obj5 = 0 ;
18131     PyObject * obj6 = 0 ;
18132     char *kwnames[] = {
18133         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18134     };
18135
18136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Choicebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18138     if (SWIG_arg_fail(1)) SWIG_fail;
18139     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18140     if (SWIG_arg_fail(2)) SWIG_fail;
18141     {
18142         arg3 = (int)(SWIG_As_int(obj2));
18143         if (SWIG_arg_fail(3)) SWIG_fail;
18144     }
18145     if (obj3) {
18146         {
18147             arg4 = &temp4;
18148             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
18149         }
18150     }
18151     if (obj4) {
18152         {
18153             arg5 = &temp5;
18154             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
18155         }
18156     }
18157     if (obj5) {
18158         {
18159             arg6 = (long)(SWIG_As_long(obj5));
18160             if (SWIG_arg_fail(6)) SWIG_fail;
18161         }
18162     }
18163     if (obj6) {
18164         {
18165             arg7 = wxString_in_helper(obj6);
18166             if (arg7 == NULL) SWIG_fail;
18167             temp7 = true;
18168         }
18169     }
18170     {
18171         PyThreadState* __tstate = wxPyBeginAllowThreads();
18172         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
18173
18174         wxPyEndAllowThreads(__tstate);
18175         if (PyErr_Occurred()) SWIG_fail;
18176     }
18177     {
18178         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18179     }
18180     {
18181         if (temp7)
18182         delete arg7;
18183     }
18184     return resultobj;
18185     fail:
18186     {
18187         if (temp7)
18188         delete arg7;
18189     }
18190     return NULL;
18191 }
18192
18193
18194 static PyObject *_wrap_Choicebook_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
18195     PyObject *resultobj;
18196     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18197     bool result;
18198     PyObject * obj0 = 0 ;
18199     char *kwnames[] = {
18200         (char *) "self", NULL
18201     };
18202
18203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Choicebook_IsVertical",kwnames,&obj0)) goto fail;
18204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18205     if (SWIG_arg_fail(1)) SWIG_fail;
18206     {
18207         PyThreadState* __tstate = wxPyBeginAllowThreads();
18208         result = (bool)((wxChoicebook const *)arg1)->IsVertical();
18209
18210         wxPyEndAllowThreads(__tstate);
18211         if (PyErr_Occurred()) SWIG_fail;
18212     }
18213     {
18214         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18215     }
18216     return resultobj;
18217     fail:
18218     return NULL;
18219 }
18220
18221
18222 static PyObject *_wrap_Choicebook_DeleteAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
18223     PyObject *resultobj;
18224     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18225     bool result;
18226     PyObject * obj0 = 0 ;
18227     char *kwnames[] = {
18228         (char *) "self", NULL
18229     };
18230
18231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Choicebook_DeleteAllPages",kwnames,&obj0)) goto fail;
18232     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18233     if (SWIG_arg_fail(1)) SWIG_fail;
18234     {
18235         PyThreadState* __tstate = wxPyBeginAllowThreads();
18236         result = (bool)(arg1)->DeleteAllPages();
18237
18238         wxPyEndAllowThreads(__tstate);
18239         if (PyErr_Occurred()) SWIG_fail;
18240     }
18241     {
18242         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18243     }
18244     return resultobj;
18245     fail:
18246     return NULL;
18247 }
18248
18249
18250 static PyObject * Choicebook_swigregister(PyObject *, PyObject *args) {
18251     PyObject *obj;
18252     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18253     SWIG_TypeClientData(SWIGTYPE_p_wxChoicebook, obj);
18254     Py_INCREF(obj);
18255     return Py_BuildValue((char *)"");
18256 }
18257 static PyObject *_wrap_new_ChoicebookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18258     PyObject *resultobj;
18259     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18260     int arg2 = (int) 0 ;
18261     int arg3 = (int) -1 ;
18262     int arg4 = (int) -1 ;
18263     wxChoicebookEvent *result;
18264     PyObject * obj0 = 0 ;
18265     PyObject * obj1 = 0 ;
18266     PyObject * obj2 = 0 ;
18267     PyObject * obj3 = 0 ;
18268     char *kwnames[] = {
18269         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
18270     };
18271
18272     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ChoicebookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18273     if (obj0) {
18274         {
18275             arg1 = (wxEventType)(SWIG_As_int(obj0));
18276             if (SWIG_arg_fail(1)) SWIG_fail;
18277         }
18278     }
18279     if (obj1) {
18280         {
18281             arg2 = (int)(SWIG_As_int(obj1));
18282             if (SWIG_arg_fail(2)) SWIG_fail;
18283         }
18284     }
18285     if (obj2) {
18286         {
18287             arg3 = (int)(SWIG_As_int(obj2));
18288             if (SWIG_arg_fail(3)) SWIG_fail;
18289         }
18290     }
18291     if (obj3) {
18292         {
18293             arg4 = (int)(SWIG_As_int(obj3));
18294             if (SWIG_arg_fail(4)) SWIG_fail;
18295         }
18296     }
18297     {
18298         PyThreadState* __tstate = wxPyBeginAllowThreads();
18299         result = (wxChoicebookEvent *)new wxChoicebookEvent(arg1,arg2,arg3,arg4);
18300
18301         wxPyEndAllowThreads(__tstate);
18302         if (PyErr_Occurred()) SWIG_fail;
18303     }
18304     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebookEvent, 1);
18305     return resultobj;
18306     fail:
18307     return NULL;
18308 }
18309
18310
18311 static PyObject * ChoicebookEvent_swigregister(PyObject *, PyObject *args) {
18312     PyObject *obj;
18313     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18314     SWIG_TypeClientData(SWIGTYPE_p_wxChoicebookEvent, obj);
18315     Py_INCREF(obj);
18316     return Py_BuildValue((char *)"");
18317 }
18318 static PyObject *_wrap_new_BookCtrlSizer(PyObject *, PyObject *args, PyObject *kwargs) {
18319     PyObject *resultobj;
18320     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
18321     wxBookCtrlSizer *result;
18322     PyObject * obj0 = 0 ;
18323     char *kwnames[] = {
18324         (char *) "nb", NULL
18325     };
18326
18327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BookCtrlSizer",kwnames,&obj0)) goto fail;
18328     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
18329     if (SWIG_arg_fail(1)) SWIG_fail;
18330     {
18331         PyThreadState* __tstate = wxPyBeginAllowThreads();
18332         result = (wxBookCtrlSizer *)new wxBookCtrlSizer(arg1);
18333
18334         wxPyEndAllowThreads(__tstate);
18335         if (PyErr_Occurred()) SWIG_fail;
18336     }
18337     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlSizer, 1);
18338     return resultobj;
18339     fail:
18340     return NULL;
18341 }
18342
18343
18344 static PyObject *_wrap_BookCtrlSizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
18345     PyObject *resultobj;
18346     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18347     PyObject * obj0 = 0 ;
18348     char *kwnames[] = {
18349         (char *) "self", NULL
18350     };
18351
18352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_RecalcSizes",kwnames,&obj0)) goto fail;
18353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18354     if (SWIG_arg_fail(1)) SWIG_fail;
18355     {
18356         PyThreadState* __tstate = wxPyBeginAllowThreads();
18357         (arg1)->RecalcSizes();
18358
18359         wxPyEndAllowThreads(__tstate);
18360         if (PyErr_Occurred()) SWIG_fail;
18361     }
18362     Py_INCREF(Py_None); resultobj = Py_None;
18363     return resultobj;
18364     fail:
18365     return NULL;
18366 }
18367
18368
18369 static PyObject *_wrap_BookCtrlSizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
18370     PyObject *resultobj;
18371     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18372     wxSize result;
18373     PyObject * obj0 = 0 ;
18374     char *kwnames[] = {
18375         (char *) "self", NULL
18376     };
18377
18378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_CalcMin",kwnames,&obj0)) goto fail;
18379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18380     if (SWIG_arg_fail(1)) SWIG_fail;
18381     {
18382         PyThreadState* __tstate = wxPyBeginAllowThreads();
18383         result = (arg1)->CalcMin();
18384
18385         wxPyEndAllowThreads(__tstate);
18386         if (PyErr_Occurred()) SWIG_fail;
18387     }
18388     {
18389         wxSize * resultptr;
18390         resultptr = new wxSize((wxSize &)(result));
18391         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18392     }
18393     return resultobj;
18394     fail:
18395     return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_BookCtrlSizer_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18400     PyObject *resultobj;
18401     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18402     wxBookCtrlBase *result;
18403     PyObject * obj0 = 0 ;
18404     char *kwnames[] = {
18405         (char *) "self", NULL
18406     };
18407
18408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_GetControl",kwnames,&obj0)) goto fail;
18409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18410     if (SWIG_arg_fail(1)) SWIG_fail;
18411     {
18412         PyThreadState* __tstate = wxPyBeginAllowThreads();
18413         result = (wxBookCtrlBase *)(arg1)->GetControl();
18414
18415         wxPyEndAllowThreads(__tstate);
18416         if (PyErr_Occurred()) SWIG_fail;
18417     }
18418     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlBase, 0);
18419     return resultobj;
18420     fail:
18421     return NULL;
18422 }
18423
18424
18425 static PyObject * BookCtrlSizer_swigregister(PyObject *, PyObject *args) {
18426     PyObject *obj;
18427     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18428     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlSizer, obj);
18429     Py_INCREF(obj);
18430     return Py_BuildValue((char *)"");
18431 }
18432 static PyObject *_wrap_new_NotebookSizer(PyObject *, PyObject *args, PyObject *kwargs) {
18433     PyObject *resultobj;
18434     wxNotebook *arg1 = (wxNotebook *) 0 ;
18435     wxNotebookSizer *result;
18436     PyObject * obj0 = 0 ;
18437     char *kwnames[] = {
18438         (char *) "nb", NULL
18439     };
18440
18441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NotebookSizer",kwnames,&obj0)) goto fail;
18442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
18443     if (SWIG_arg_fail(1)) SWIG_fail;
18444     {
18445         PyThreadState* __tstate = wxPyBeginAllowThreads();
18446         result = (wxNotebookSizer *)new wxNotebookSizer(arg1);
18447
18448         wxPyEndAllowThreads(__tstate);
18449         if (PyErr_Occurred()) SWIG_fail;
18450     }
18451     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebookSizer, 1);
18452     return resultobj;
18453     fail:
18454     return NULL;
18455 }
18456
18457
18458 static PyObject *_wrap_NotebookSizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
18459     PyObject *resultobj;
18460     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18461     PyObject * obj0 = 0 ;
18462     char *kwnames[] = {
18463         (char *) "self", NULL
18464     };
18465
18466     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_RecalcSizes",kwnames,&obj0)) goto fail;
18467     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18468     if (SWIG_arg_fail(1)) SWIG_fail;
18469     {
18470         PyThreadState* __tstate = wxPyBeginAllowThreads();
18471         (arg1)->RecalcSizes();
18472
18473         wxPyEndAllowThreads(__tstate);
18474         if (PyErr_Occurred()) SWIG_fail;
18475     }
18476     Py_INCREF(Py_None); resultobj = Py_None;
18477     return resultobj;
18478     fail:
18479     return NULL;
18480 }
18481
18482
18483 static PyObject *_wrap_NotebookSizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
18484     PyObject *resultobj;
18485     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18486     wxSize result;
18487     PyObject * obj0 = 0 ;
18488     char *kwnames[] = {
18489         (char *) "self", NULL
18490     };
18491
18492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_CalcMin",kwnames,&obj0)) goto fail;
18493     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18494     if (SWIG_arg_fail(1)) SWIG_fail;
18495     {
18496         PyThreadState* __tstate = wxPyBeginAllowThreads();
18497         result = (arg1)->CalcMin();
18498
18499         wxPyEndAllowThreads(__tstate);
18500         if (PyErr_Occurred()) SWIG_fail;
18501     }
18502     {
18503         wxSize * resultptr;
18504         resultptr = new wxSize((wxSize &)(result));
18505         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18506     }
18507     return resultobj;
18508     fail:
18509     return NULL;
18510 }
18511
18512
18513 static PyObject *_wrap_NotebookSizer_GetNotebook(PyObject *, PyObject *args, PyObject *kwargs) {
18514     PyObject *resultobj;
18515     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18516     wxNotebook *result;
18517     PyObject * obj0 = 0 ;
18518     char *kwnames[] = {
18519         (char *) "self", NULL
18520     };
18521
18522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_GetNotebook",kwnames,&obj0)) goto fail;
18523     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18524     if (SWIG_arg_fail(1)) SWIG_fail;
18525     {
18526         PyThreadState* __tstate = wxPyBeginAllowThreads();
18527         result = (wxNotebook *)(arg1)->GetNotebook();
18528
18529         wxPyEndAllowThreads(__tstate);
18530         if (PyErr_Occurred()) SWIG_fail;
18531     }
18532     {
18533         resultobj = wxPyMake_wxObject(result, 0);
18534     }
18535     return resultobj;
18536     fail:
18537     return NULL;
18538 }
18539
18540
18541 static PyObject * NotebookSizer_swigregister(PyObject *, PyObject *args) {
18542     PyObject *obj;
18543     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18544     SWIG_TypeClientData(SWIGTYPE_p_wxNotebookSizer, obj);
18545     Py_INCREF(obj);
18546     return Py_BuildValue((char *)"");
18547 }
18548 static PyObject *_wrap_ToolBarToolBase_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
18549     PyObject *resultobj;
18550     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18551     int result;
18552     PyObject * obj0 = 0 ;
18553     char *kwnames[] = {
18554         (char *) "self", NULL
18555     };
18556
18557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetId",kwnames,&obj0)) goto fail;
18558     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18559     if (SWIG_arg_fail(1)) SWIG_fail;
18560     {
18561         PyThreadState* __tstate = wxPyBeginAllowThreads();
18562         result = (int)(arg1)->GetId();
18563
18564         wxPyEndAllowThreads(__tstate);
18565         if (PyErr_Occurred()) SWIG_fail;
18566     }
18567     {
18568         resultobj = SWIG_From_int((int)(result));
18569     }
18570     return resultobj;
18571     fail:
18572     return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_ToolBarToolBase_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18577     PyObject *resultobj;
18578     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18579     wxControl *result;
18580     PyObject * obj0 = 0 ;
18581     char *kwnames[] = {
18582         (char *) "self", NULL
18583     };
18584
18585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetControl",kwnames,&obj0)) goto fail;
18586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18587     if (SWIG_arg_fail(1)) SWIG_fail;
18588     {
18589         PyThreadState* __tstate = wxPyBeginAllowThreads();
18590         result = (wxControl *)(arg1)->GetControl();
18591
18592         wxPyEndAllowThreads(__tstate);
18593         if (PyErr_Occurred()) SWIG_fail;
18594     }
18595     {
18596         resultobj = wxPyMake_wxObject(result, 0);
18597     }
18598     return resultobj;
18599     fail:
18600     return NULL;
18601 }
18602
18603
18604 static PyObject *_wrap_ToolBarToolBase_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
18605     PyObject *resultobj;
18606     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18607     wxToolBarBase *result;
18608     PyObject * obj0 = 0 ;
18609     char *kwnames[] = {
18610         (char *) "self", NULL
18611     };
18612
18613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetToolBar",kwnames,&obj0)) goto fail;
18614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18615     if (SWIG_arg_fail(1)) SWIG_fail;
18616     {
18617         PyThreadState* __tstate = wxPyBeginAllowThreads();
18618         result = (wxToolBarBase *)(arg1)->GetToolBar();
18619
18620         wxPyEndAllowThreads(__tstate);
18621         if (PyErr_Occurred()) SWIG_fail;
18622     }
18623     {
18624         resultobj = wxPyMake_wxObject(result, 0);
18625     }
18626     return resultobj;
18627     fail:
18628     return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_ToolBarToolBase_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
18633     PyObject *resultobj;
18634     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18635     int result;
18636     PyObject * obj0 = 0 ;
18637     char *kwnames[] = {
18638         (char *) "self", NULL
18639     };
18640
18641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsButton",kwnames,&obj0)) goto fail;
18642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18643     if (SWIG_arg_fail(1)) SWIG_fail;
18644     {
18645         PyThreadState* __tstate = wxPyBeginAllowThreads();
18646         result = (int)(arg1)->IsButton();
18647
18648         wxPyEndAllowThreads(__tstate);
18649         if (PyErr_Occurred()) SWIG_fail;
18650     }
18651     {
18652         resultobj = SWIG_From_int((int)(result));
18653     }
18654     return resultobj;
18655     fail:
18656     return NULL;
18657 }
18658
18659
18660 static PyObject *_wrap_ToolBarToolBase_IsControl(PyObject *, PyObject *args, PyObject *kwargs) {
18661     PyObject *resultobj;
18662     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18663     int result;
18664     PyObject * obj0 = 0 ;
18665     char *kwnames[] = {
18666         (char *) "self", NULL
18667     };
18668
18669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsControl",kwnames,&obj0)) goto fail;
18670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18671     if (SWIG_arg_fail(1)) SWIG_fail;
18672     {
18673         PyThreadState* __tstate = wxPyBeginAllowThreads();
18674         result = (int)(arg1)->IsControl();
18675
18676         wxPyEndAllowThreads(__tstate);
18677         if (PyErr_Occurred()) SWIG_fail;
18678     }
18679     {
18680         resultobj = SWIG_From_int((int)(result));
18681     }
18682     return resultobj;
18683     fail:
18684     return NULL;
18685 }
18686
18687
18688 static PyObject *_wrap_ToolBarToolBase_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
18689     PyObject *resultobj;
18690     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18691     int result;
18692     PyObject * obj0 = 0 ;
18693     char *kwnames[] = {
18694         (char *) "self", NULL
18695     };
18696
18697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsSeparator",kwnames,&obj0)) goto fail;
18698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18699     if (SWIG_arg_fail(1)) SWIG_fail;
18700     {
18701         PyThreadState* __tstate = wxPyBeginAllowThreads();
18702         result = (int)(arg1)->IsSeparator();
18703
18704         wxPyEndAllowThreads(__tstate);
18705         if (PyErr_Occurred()) SWIG_fail;
18706     }
18707     {
18708         resultobj = SWIG_From_int((int)(result));
18709     }
18710     return resultobj;
18711     fail:
18712     return NULL;
18713 }
18714
18715
18716 static PyObject *_wrap_ToolBarToolBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18717     PyObject *resultobj;
18718     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18719     int result;
18720     PyObject * obj0 = 0 ;
18721     char *kwnames[] = {
18722         (char *) "self", NULL
18723     };
18724
18725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetStyle",kwnames,&obj0)) goto fail;
18726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18727     if (SWIG_arg_fail(1)) SWIG_fail;
18728     {
18729         PyThreadState* __tstate = wxPyBeginAllowThreads();
18730         result = (int)(arg1)->GetStyle();
18731
18732         wxPyEndAllowThreads(__tstate);
18733         if (PyErr_Occurred()) SWIG_fail;
18734     }
18735     {
18736         resultobj = SWIG_From_int((int)(result));
18737     }
18738     return resultobj;
18739     fail:
18740     return NULL;
18741 }
18742
18743
18744 static PyObject *_wrap_ToolBarToolBase_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
18745     PyObject *resultobj;
18746     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18747     wxItemKind result;
18748     PyObject * obj0 = 0 ;
18749     char *kwnames[] = {
18750         (char *) "self", NULL
18751     };
18752
18753     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetKind",kwnames,&obj0)) goto fail;
18754     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18755     if (SWIG_arg_fail(1)) SWIG_fail;
18756     {
18757         PyThreadState* __tstate = wxPyBeginAllowThreads();
18758         result = (wxItemKind)(arg1)->GetKind();
18759
18760         wxPyEndAllowThreads(__tstate);
18761         if (PyErr_Occurred()) SWIG_fail;
18762     }
18763     resultobj = SWIG_From_int((result));
18764     return resultobj;
18765     fail:
18766     return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_ToolBarToolBase_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
18771     PyObject *resultobj;
18772     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18773     bool result;
18774     PyObject * obj0 = 0 ;
18775     char *kwnames[] = {
18776         (char *) "self", NULL
18777     };
18778
18779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsEnabled",kwnames,&obj0)) goto fail;
18780     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18781     if (SWIG_arg_fail(1)) SWIG_fail;
18782     {
18783         PyThreadState* __tstate = wxPyBeginAllowThreads();
18784         result = (bool)(arg1)->IsEnabled();
18785
18786         wxPyEndAllowThreads(__tstate);
18787         if (PyErr_Occurred()) SWIG_fail;
18788     }
18789     {
18790         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18791     }
18792     return resultobj;
18793     fail:
18794     return NULL;
18795 }
18796
18797
18798 static PyObject *_wrap_ToolBarToolBase_IsToggled(PyObject *, PyObject *args, PyObject *kwargs) {
18799     PyObject *resultobj;
18800     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18801     bool result;
18802     PyObject * obj0 = 0 ;
18803     char *kwnames[] = {
18804         (char *) "self", NULL
18805     };
18806
18807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsToggled",kwnames,&obj0)) goto fail;
18808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18809     if (SWIG_arg_fail(1)) SWIG_fail;
18810     {
18811         PyThreadState* __tstate = wxPyBeginAllowThreads();
18812         result = (bool)(arg1)->IsToggled();
18813
18814         wxPyEndAllowThreads(__tstate);
18815         if (PyErr_Occurred()) SWIG_fail;
18816     }
18817     {
18818         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18819     }
18820     return resultobj;
18821     fail:
18822     return NULL;
18823 }
18824
18825
18826 static PyObject *_wrap_ToolBarToolBase_CanBeToggled(PyObject *, PyObject *args, PyObject *kwargs) {
18827     PyObject *resultobj;
18828     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18829     bool result;
18830     PyObject * obj0 = 0 ;
18831     char *kwnames[] = {
18832         (char *) "self", NULL
18833     };
18834
18835     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_CanBeToggled",kwnames,&obj0)) goto fail;
18836     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18837     if (SWIG_arg_fail(1)) SWIG_fail;
18838     {
18839         PyThreadState* __tstate = wxPyBeginAllowThreads();
18840         result = (bool)(arg1)->CanBeToggled();
18841
18842         wxPyEndAllowThreads(__tstate);
18843         if (PyErr_Occurred()) SWIG_fail;
18844     }
18845     {
18846         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18847     }
18848     return resultobj;
18849     fail:
18850     return NULL;
18851 }
18852
18853
18854 static PyObject *_wrap_ToolBarToolBase_GetNormalBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18855     PyObject *resultobj;
18856     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18857     wxBitmap *result;
18858     PyObject * obj0 = 0 ;
18859     char *kwnames[] = {
18860         (char *) "self", NULL
18861     };
18862
18863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetNormalBitmap",kwnames,&obj0)) goto fail;
18864     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18865     if (SWIG_arg_fail(1)) SWIG_fail;
18866     {
18867         PyThreadState* __tstate = wxPyBeginAllowThreads();
18868         {
18869             wxBitmap const &_result_ref = (arg1)->GetNormalBitmap();
18870             result = (wxBitmap *) &_result_ref;
18871         }
18872
18873         wxPyEndAllowThreads(__tstate);
18874         if (PyErr_Occurred()) SWIG_fail;
18875     }
18876     {
18877         wxBitmap* resultptr = new wxBitmap(*result);
18878         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18879     }
18880     return resultobj;
18881     fail:
18882     return NULL;
18883 }
18884
18885
18886 static PyObject *_wrap_ToolBarToolBase_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18887     PyObject *resultobj;
18888     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18889     wxBitmap *result;
18890     PyObject * obj0 = 0 ;
18891     char *kwnames[] = {
18892         (char *) "self", NULL
18893     };
18894
18895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetDisabledBitmap",kwnames,&obj0)) goto fail;
18896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18897     if (SWIG_arg_fail(1)) SWIG_fail;
18898     {
18899         PyThreadState* __tstate = wxPyBeginAllowThreads();
18900         {
18901             wxBitmap const &_result_ref = (arg1)->GetDisabledBitmap();
18902             result = (wxBitmap *) &_result_ref;
18903         }
18904
18905         wxPyEndAllowThreads(__tstate);
18906         if (PyErr_Occurred()) SWIG_fail;
18907     }
18908     {
18909         wxBitmap* resultptr = new wxBitmap(*result);
18910         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18911     }
18912     return resultobj;
18913     fail:
18914     return NULL;
18915 }
18916
18917
18918 static PyObject *_wrap_ToolBarToolBase_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18919     PyObject *resultobj;
18920     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18921     wxBitmap result;
18922     PyObject * obj0 = 0 ;
18923     char *kwnames[] = {
18924         (char *) "self", NULL
18925     };
18926
18927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetBitmap",kwnames,&obj0)) goto fail;
18928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18929     if (SWIG_arg_fail(1)) SWIG_fail;
18930     {
18931         PyThreadState* __tstate = wxPyBeginAllowThreads();
18932         result = (arg1)->GetBitmap();
18933
18934         wxPyEndAllowThreads(__tstate);
18935         if (PyErr_Occurred()) SWIG_fail;
18936     }
18937     {
18938         wxBitmap * resultptr;
18939         resultptr = new wxBitmap((wxBitmap &)(result));
18940         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18941     }
18942     return resultobj;
18943     fail:
18944     return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_ToolBarToolBase_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
18949     PyObject *resultobj;
18950     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18951     wxString result;
18952     PyObject * obj0 = 0 ;
18953     char *kwnames[] = {
18954         (char *) "self", NULL
18955     };
18956
18957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetLabel",kwnames,&obj0)) goto fail;
18958     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18959     if (SWIG_arg_fail(1)) SWIG_fail;
18960     {
18961         PyThreadState* __tstate = wxPyBeginAllowThreads();
18962         result = (arg1)->GetLabel();
18963
18964         wxPyEndAllowThreads(__tstate);
18965         if (PyErr_Occurred()) SWIG_fail;
18966     }
18967     {
18968 #if wxUSE_UNICODE
18969         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18970 #else
18971         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18972 #endif
18973     }
18974     return resultobj;
18975     fail:
18976     return NULL;
18977 }
18978
18979
18980 static PyObject *_wrap_ToolBarToolBase_GetShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
18981     PyObject *resultobj;
18982     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18983     wxString result;
18984     PyObject * obj0 = 0 ;
18985     char *kwnames[] = {
18986         (char *) "self", NULL
18987     };
18988
18989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetShortHelp",kwnames,&obj0)) goto fail;
18990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18991     if (SWIG_arg_fail(1)) SWIG_fail;
18992     {
18993         PyThreadState* __tstate = wxPyBeginAllowThreads();
18994         result = (arg1)->GetShortHelp();
18995
18996         wxPyEndAllowThreads(__tstate);
18997         if (PyErr_Occurred()) SWIG_fail;
18998     }
18999     {
19000 #if wxUSE_UNICODE
19001         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19002 #else
19003         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19004 #endif
19005     }
19006     return resultobj;
19007     fail:
19008     return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_ToolBarToolBase_GetLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19013     PyObject *resultobj;
19014     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19015     wxString result;
19016     PyObject * obj0 = 0 ;
19017     char *kwnames[] = {
19018         (char *) "self", NULL
19019     };
19020
19021     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetLongHelp",kwnames,&obj0)) goto fail;
19022     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19023     if (SWIG_arg_fail(1)) SWIG_fail;
19024     {
19025         PyThreadState* __tstate = wxPyBeginAllowThreads();
19026         result = (arg1)->GetLongHelp();
19027
19028         wxPyEndAllowThreads(__tstate);
19029         if (PyErr_Occurred()) SWIG_fail;
19030     }
19031     {
19032 #if wxUSE_UNICODE
19033         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19034 #else
19035         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19036 #endif
19037     }
19038     return resultobj;
19039     fail:
19040     return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_ToolBarToolBase_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
19045     PyObject *resultobj;
19046     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19047     bool arg2 ;
19048     bool result;
19049     PyObject * obj0 = 0 ;
19050     PyObject * obj1 = 0 ;
19051     char *kwnames[] = {
19052         (char *) "self",(char *) "enable", NULL
19053     };
19054
19055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Enable",kwnames,&obj0,&obj1)) goto fail;
19056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19057     if (SWIG_arg_fail(1)) SWIG_fail;
19058     {
19059         arg2 = (bool)(SWIG_As_bool(obj1));
19060         if (SWIG_arg_fail(2)) SWIG_fail;
19061     }
19062     {
19063         PyThreadState* __tstate = wxPyBeginAllowThreads();
19064         result = (bool)(arg1)->Enable(arg2);
19065
19066         wxPyEndAllowThreads(__tstate);
19067         if (PyErr_Occurred()) SWIG_fail;
19068     }
19069     {
19070         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19071     }
19072     return resultobj;
19073     fail:
19074     return NULL;
19075 }
19076
19077
19078 static PyObject *_wrap_ToolBarToolBase_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
19079     PyObject *resultobj;
19080     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19081     PyObject * obj0 = 0 ;
19082     char *kwnames[] = {
19083         (char *) "self", NULL
19084     };
19085
19086     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_Toggle",kwnames,&obj0)) goto fail;
19087     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19088     if (SWIG_arg_fail(1)) SWIG_fail;
19089     {
19090         PyThreadState* __tstate = wxPyBeginAllowThreads();
19091         (arg1)->Toggle();
19092
19093         wxPyEndAllowThreads(__tstate);
19094         if (PyErr_Occurred()) SWIG_fail;
19095     }
19096     Py_INCREF(Py_None); resultobj = Py_None;
19097     return resultobj;
19098     fail:
19099     return NULL;
19100 }
19101
19102
19103 static PyObject *_wrap_ToolBarToolBase_SetToggle(PyObject *, PyObject *args, PyObject *kwargs) {
19104     PyObject *resultobj;
19105     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19106     bool arg2 ;
19107     bool result;
19108     PyObject * obj0 = 0 ;
19109     PyObject * obj1 = 0 ;
19110     char *kwnames[] = {
19111         (char *) "self",(char *) "toggle", NULL
19112     };
19113
19114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetToggle",kwnames,&obj0,&obj1)) goto fail;
19115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19116     if (SWIG_arg_fail(1)) SWIG_fail;
19117     {
19118         arg2 = (bool)(SWIG_As_bool(obj1));
19119         if (SWIG_arg_fail(2)) SWIG_fail;
19120     }
19121     {
19122         PyThreadState* __tstate = wxPyBeginAllowThreads();
19123         result = (bool)(arg1)->SetToggle(arg2);
19124
19125         wxPyEndAllowThreads(__tstate);
19126         if (PyErr_Occurred()) SWIG_fail;
19127     }
19128     {
19129         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19130     }
19131     return resultobj;
19132     fail:
19133     return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_ToolBarToolBase_SetShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19138     PyObject *resultobj;
19139     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19140     wxString *arg2 = 0 ;
19141     bool result;
19142     bool temp2 = false ;
19143     PyObject * obj0 = 0 ;
19144     PyObject * obj1 = 0 ;
19145     char *kwnames[] = {
19146         (char *) "self",(char *) "help", NULL
19147     };
19148
19149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetShortHelp",kwnames,&obj0,&obj1)) goto fail;
19150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19151     if (SWIG_arg_fail(1)) SWIG_fail;
19152     {
19153         arg2 = wxString_in_helper(obj1);
19154         if (arg2 == NULL) SWIG_fail;
19155         temp2 = true;
19156     }
19157     {
19158         PyThreadState* __tstate = wxPyBeginAllowThreads();
19159         result = (bool)(arg1)->SetShortHelp((wxString const &)*arg2);
19160
19161         wxPyEndAllowThreads(__tstate);
19162         if (PyErr_Occurred()) SWIG_fail;
19163     }
19164     {
19165         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19166     }
19167     {
19168         if (temp2)
19169         delete arg2;
19170     }
19171     return resultobj;
19172     fail:
19173     {
19174         if (temp2)
19175         delete arg2;
19176     }
19177     return NULL;
19178 }
19179
19180
19181 static PyObject *_wrap_ToolBarToolBase_SetLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19182     PyObject *resultobj;
19183     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19184     wxString *arg2 = 0 ;
19185     bool result;
19186     bool temp2 = false ;
19187     PyObject * obj0 = 0 ;
19188     PyObject * obj1 = 0 ;
19189     char *kwnames[] = {
19190         (char *) "self",(char *) "help", NULL
19191     };
19192
19193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLongHelp",kwnames,&obj0,&obj1)) goto fail;
19194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19195     if (SWIG_arg_fail(1)) SWIG_fail;
19196     {
19197         arg2 = wxString_in_helper(obj1);
19198         if (arg2 == NULL) SWIG_fail;
19199         temp2 = true;
19200     }
19201     {
19202         PyThreadState* __tstate = wxPyBeginAllowThreads();
19203         result = (bool)(arg1)->SetLongHelp((wxString const &)*arg2);
19204
19205         wxPyEndAllowThreads(__tstate);
19206         if (PyErr_Occurred()) SWIG_fail;
19207     }
19208     {
19209         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19210     }
19211     {
19212         if (temp2)
19213         delete arg2;
19214     }
19215     return resultobj;
19216     fail:
19217     {
19218         if (temp2)
19219         delete arg2;
19220     }
19221     return NULL;
19222 }
19223
19224
19225 static PyObject *_wrap_ToolBarToolBase_SetNormalBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19226     PyObject *resultobj;
19227     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19228     wxBitmap *arg2 = 0 ;
19229     PyObject * obj0 = 0 ;
19230     PyObject * obj1 = 0 ;
19231     char *kwnames[] = {
19232         (char *) "self",(char *) "bmp", NULL
19233     };
19234
19235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetNormalBitmap",kwnames,&obj0,&obj1)) goto fail;
19236     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19237     if (SWIG_arg_fail(1)) SWIG_fail;
19238     {
19239         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19240         if (SWIG_arg_fail(2)) SWIG_fail;
19241         if (arg2 == NULL) {
19242             SWIG_null_ref("wxBitmap");
19243         }
19244         if (SWIG_arg_fail(2)) SWIG_fail;
19245     }
19246     {
19247         PyThreadState* __tstate = wxPyBeginAllowThreads();
19248         (arg1)->SetNormalBitmap((wxBitmap const &)*arg2);
19249
19250         wxPyEndAllowThreads(__tstate);
19251         if (PyErr_Occurred()) SWIG_fail;
19252     }
19253     Py_INCREF(Py_None); resultobj = Py_None;
19254     return resultobj;
19255     fail:
19256     return NULL;
19257 }
19258
19259
19260 static PyObject *_wrap_ToolBarToolBase_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19261     PyObject *resultobj;
19262     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19263     wxBitmap *arg2 = 0 ;
19264     PyObject * obj0 = 0 ;
19265     PyObject * obj1 = 0 ;
19266     char *kwnames[] = {
19267         (char *) "self",(char *) "bmp", NULL
19268     };
19269
19270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
19271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19272     if (SWIG_arg_fail(1)) SWIG_fail;
19273     {
19274         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19275         if (SWIG_arg_fail(2)) SWIG_fail;
19276         if (arg2 == NULL) {
19277             SWIG_null_ref("wxBitmap");
19278         }
19279         if (SWIG_arg_fail(2)) SWIG_fail;
19280     }
19281     {
19282         PyThreadState* __tstate = wxPyBeginAllowThreads();
19283         (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
19284
19285         wxPyEndAllowThreads(__tstate);
19286         if (PyErr_Occurred()) SWIG_fail;
19287     }
19288     Py_INCREF(Py_None); resultobj = Py_None;
19289     return resultobj;
19290     fail:
19291     return NULL;
19292 }
19293
19294
19295 static PyObject *_wrap_ToolBarToolBase_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
19296     PyObject *resultobj;
19297     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19298     wxString *arg2 = 0 ;
19299     bool temp2 = false ;
19300     PyObject * obj0 = 0 ;
19301     PyObject * obj1 = 0 ;
19302     char *kwnames[] = {
19303         (char *) "self",(char *) "label", NULL
19304     };
19305
19306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLabel",kwnames,&obj0,&obj1)) goto fail;
19307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19308     if (SWIG_arg_fail(1)) SWIG_fail;
19309     {
19310         arg2 = wxString_in_helper(obj1);
19311         if (arg2 == NULL) SWIG_fail;
19312         temp2 = true;
19313     }
19314     {
19315         PyThreadState* __tstate = wxPyBeginAllowThreads();
19316         (arg1)->SetLabel((wxString const &)*arg2);
19317
19318         wxPyEndAllowThreads(__tstate);
19319         if (PyErr_Occurred()) SWIG_fail;
19320     }
19321     Py_INCREF(Py_None); resultobj = Py_None;
19322     {
19323         if (temp2)
19324         delete arg2;
19325     }
19326     return resultobj;
19327     fail:
19328     {
19329         if (temp2)
19330         delete arg2;
19331     }
19332     return NULL;
19333 }
19334
19335
19336 static PyObject *_wrap_ToolBarToolBase_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
19337     PyObject *resultobj;
19338     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19339     PyObject * obj0 = 0 ;
19340     char *kwnames[] = {
19341         (char *) "self", NULL
19342     };
19343
19344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_Detach",kwnames,&obj0)) goto fail;
19345     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19346     if (SWIG_arg_fail(1)) SWIG_fail;
19347     {
19348         PyThreadState* __tstate = wxPyBeginAllowThreads();
19349         (arg1)->Detach();
19350
19351         wxPyEndAllowThreads(__tstate);
19352         if (PyErr_Occurred()) SWIG_fail;
19353     }
19354     Py_INCREF(Py_None); resultobj = Py_None;
19355     return resultobj;
19356     fail:
19357     return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_ToolBarToolBase_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
19362     PyObject *resultobj;
19363     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19364     wxToolBarBase *arg2 = (wxToolBarBase *) 0 ;
19365     PyObject * obj0 = 0 ;
19366     PyObject * obj1 = 0 ;
19367     char *kwnames[] = {
19368         (char *) "self",(char *) "tbar", NULL
19369     };
19370
19371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Attach",kwnames,&obj0,&obj1)) goto fail;
19372     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19373     if (SWIG_arg_fail(1)) SWIG_fail;
19374     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19375     if (SWIG_arg_fail(2)) SWIG_fail;
19376     {
19377         PyThreadState* __tstate = wxPyBeginAllowThreads();
19378         (arg1)->Attach(arg2);
19379
19380         wxPyEndAllowThreads(__tstate);
19381         if (PyErr_Occurred()) SWIG_fail;
19382     }
19383     Py_INCREF(Py_None); resultobj = Py_None;
19384     return resultobj;
19385     fail:
19386     return NULL;
19387 }
19388
19389
19390 static PyObject *_wrap_ToolBarToolBase_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
19391     PyObject *resultobj;
19392     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19393     PyObject *result;
19394     PyObject * obj0 = 0 ;
19395     char *kwnames[] = {
19396         (char *) "self", NULL
19397     };
19398
19399     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetClientData",kwnames,&obj0)) goto fail;
19400     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19401     if (SWIG_arg_fail(1)) SWIG_fail;
19402     {
19403         PyThreadState* __tstate = wxPyBeginAllowThreads();
19404         result = (PyObject *)wxToolBarToolBase_GetClientData(arg1);
19405
19406         wxPyEndAllowThreads(__tstate);
19407         if (PyErr_Occurred()) SWIG_fail;
19408     }
19409     resultobj = result;
19410     return resultobj;
19411     fail:
19412     return NULL;
19413 }
19414
19415
19416 static PyObject *_wrap_ToolBarToolBase_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
19417     PyObject *resultobj;
19418     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19419     PyObject *arg2 = (PyObject *) 0 ;
19420     PyObject * obj0 = 0 ;
19421     PyObject * obj1 = 0 ;
19422     char *kwnames[] = {
19423         (char *) "self",(char *) "clientData", NULL
19424     };
19425
19426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetClientData",kwnames,&obj0,&obj1)) goto fail;
19427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19428     if (SWIG_arg_fail(1)) SWIG_fail;
19429     arg2 = obj1;
19430     {
19431         PyThreadState* __tstate = wxPyBeginAllowThreads();
19432         wxToolBarToolBase_SetClientData(arg1,arg2);
19433
19434         wxPyEndAllowThreads(__tstate);
19435         if (PyErr_Occurred()) SWIG_fail;
19436     }
19437     Py_INCREF(Py_None); resultobj = Py_None;
19438     return resultobj;
19439     fail:
19440     return NULL;
19441 }
19442
19443
19444 static PyObject * ToolBarToolBase_swigregister(PyObject *, PyObject *args) {
19445     PyObject *obj;
19446     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19447     SWIG_TypeClientData(SWIGTYPE_p_wxToolBarToolBase, obj);
19448     Py_INCREF(obj);
19449     return Py_BuildValue((char *)"");
19450 }
19451 static PyObject *_wrap_ToolBarBase_DoAddTool(PyObject *, PyObject *args, PyObject *kwargs) {
19452     PyObject *resultobj;
19453     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19454     int arg2 ;
19455     wxString *arg3 = 0 ;
19456     wxBitmap *arg4 = 0 ;
19457     wxBitmap const &arg5_defvalue = wxNullBitmap ;
19458     wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
19459     wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
19460     wxString const &arg7_defvalue = wxPyEmptyString ;
19461     wxString *arg7 = (wxString *) &arg7_defvalue ;
19462     wxString const &arg8_defvalue = wxPyEmptyString ;
19463     wxString *arg8 = (wxString *) &arg8_defvalue ;
19464     PyObject *arg9 = (PyObject *) NULL ;
19465     wxToolBarToolBase *result;
19466     bool temp3 = false ;
19467     bool temp7 = false ;
19468     bool temp8 = false ;
19469     PyObject * obj0 = 0 ;
19470     PyObject * obj1 = 0 ;
19471     PyObject * obj2 = 0 ;
19472     PyObject * obj3 = 0 ;
19473     PyObject * obj4 = 0 ;
19474     PyObject * obj5 = 0 ;
19475     PyObject * obj6 = 0 ;
19476     PyObject * obj7 = 0 ;
19477     PyObject * obj8 = 0 ;
19478     char *kwnames[] = {
19479         (char *) "self",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL
19480     };
19481
19482     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOOO:ToolBarBase_DoAddTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
19483     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19484     if (SWIG_arg_fail(1)) SWIG_fail;
19485     {
19486         arg2 = (int)(SWIG_As_int(obj1));
19487         if (SWIG_arg_fail(2)) SWIG_fail;
19488     }
19489     {
19490         arg3 = wxString_in_helper(obj2);
19491         if (arg3 == NULL) SWIG_fail;
19492         temp3 = true;
19493     }
19494     {
19495         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19496         if (SWIG_arg_fail(4)) SWIG_fail;
19497         if (arg4 == NULL) {
19498             SWIG_null_ref("wxBitmap");
19499         }
19500         if (SWIG_arg_fail(4)) SWIG_fail;
19501     }
19502     if (obj4) {
19503         {
19504             SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19505             if (SWIG_arg_fail(5)) SWIG_fail;
19506             if (arg5 == NULL) {
19507                 SWIG_null_ref("wxBitmap");
19508             }
19509             if (SWIG_arg_fail(5)) SWIG_fail;
19510         }
19511     }
19512     if (obj5) {
19513         {
19514             arg6 = (wxItemKind)(SWIG_As_int(obj5));
19515             if (SWIG_arg_fail(6)) SWIG_fail;
19516         }
19517     }
19518     if (obj6) {
19519         {
19520             arg7 = wxString_in_helper(obj6);
19521             if (arg7 == NULL) SWIG_fail;
19522             temp7 = true;
19523         }
19524     }
19525     if (obj7) {
19526         {
19527             arg8 = wxString_in_helper(obj7);
19528             if (arg8 == NULL) SWIG_fail;
19529             temp8 = true;
19530         }
19531     }
19532     if (obj8) {
19533         arg9 = obj8;
19534     }
19535     {
19536         PyThreadState* __tstate = wxPyBeginAllowThreads();
19537         result = (wxToolBarToolBase *)wxToolBarBase_DoAddTool(arg1,arg2,(wxString const &)*arg3,(wxBitmap const &)*arg4,(wxBitmap const &)*arg5,(wxItemKind )arg6,(wxString const &)*arg7,(wxString const &)*arg8,arg9);
19538
19539         wxPyEndAllowThreads(__tstate);
19540         if (PyErr_Occurred()) SWIG_fail;
19541     }
19542     {
19543         resultobj = wxPyMake_wxObject(result, 0);
19544     }
19545     {
19546         if (temp3)
19547         delete arg3;
19548     }
19549     {
19550         if (temp7)
19551         delete arg7;
19552     }
19553     {
19554         if (temp8)
19555         delete arg8;
19556     }
19557     return resultobj;
19558     fail:
19559     {
19560         if (temp3)
19561         delete arg3;
19562     }
19563     {
19564         if (temp7)
19565         delete arg7;
19566     }
19567     {
19568         if (temp8)
19569         delete arg8;
19570     }
19571     return NULL;
19572 }
19573
19574
19575 static PyObject *_wrap_ToolBarBase_DoInsertTool(PyObject *, PyObject *args, PyObject *kwargs) {
19576     PyObject *resultobj;
19577     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19578     size_t arg2 ;
19579     int arg3 ;
19580     wxString *arg4 = 0 ;
19581     wxBitmap *arg5 = 0 ;
19582     wxBitmap const &arg6_defvalue = wxNullBitmap ;
19583     wxBitmap *arg6 = (wxBitmap *) &arg6_defvalue ;
19584     wxItemKind arg7 = (wxItemKind) wxITEM_NORMAL ;
19585     wxString const &arg8_defvalue = wxPyEmptyString ;
19586     wxString *arg8 = (wxString *) &arg8_defvalue ;
19587     wxString const &arg9_defvalue = wxPyEmptyString ;
19588     wxString *arg9 = (wxString *) &arg9_defvalue ;
19589     PyObject *arg10 = (PyObject *) NULL ;
19590     wxToolBarToolBase *result;
19591     bool temp4 = false ;
19592     bool temp8 = false ;
19593     bool temp9 = false ;
19594     PyObject * obj0 = 0 ;
19595     PyObject * obj1 = 0 ;
19596     PyObject * obj2 = 0 ;
19597     PyObject * obj3 = 0 ;
19598     PyObject * obj4 = 0 ;
19599     PyObject * obj5 = 0 ;
19600     PyObject * obj6 = 0 ;
19601     PyObject * obj7 = 0 ;
19602     PyObject * obj8 = 0 ;
19603     PyObject * obj9 = 0 ;
19604     char *kwnames[] = {
19605         (char *) "self",(char *) "pos",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL
19606     };
19607
19608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:ToolBarBase_DoInsertTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
19609     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19610     if (SWIG_arg_fail(1)) SWIG_fail;
19611     {
19612         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19613         if (SWIG_arg_fail(2)) SWIG_fail;
19614     }
19615     {
19616         arg3 = (int)(SWIG_As_int(obj2));
19617         if (SWIG_arg_fail(3)) SWIG_fail;
19618     }
19619     {
19620         arg4 = wxString_in_helper(obj3);
19621         if (arg4 == NULL) SWIG_fail;
19622         temp4 = true;
19623     }
19624     {
19625         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19626         if (SWIG_arg_fail(5)) SWIG_fail;
19627         if (arg5 == NULL) {
19628             SWIG_null_ref("wxBitmap");
19629         }
19630         if (SWIG_arg_fail(5)) SWIG_fail;
19631     }
19632     if (obj5) {
19633         {
19634             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19635             if (SWIG_arg_fail(6)) SWIG_fail;
19636             if (arg6 == NULL) {
19637                 SWIG_null_ref("wxBitmap");
19638             }
19639             if (SWIG_arg_fail(6)) SWIG_fail;
19640         }
19641     }
19642     if (obj6) {
19643         {
19644             arg7 = (wxItemKind)(SWIG_As_int(obj6));
19645             if (SWIG_arg_fail(7)) SWIG_fail;
19646         }
19647     }
19648     if (obj7) {
19649         {
19650             arg8 = wxString_in_helper(obj7);
19651             if (arg8 == NULL) SWIG_fail;
19652             temp8 = true;
19653         }
19654     }
19655     if (obj8) {
19656         {
19657             arg9 = wxString_in_helper(obj8);
19658             if (arg9 == NULL) SWIG_fail;
19659             temp9 = true;
19660         }
19661     }
19662     if (obj9) {
19663         arg10 = obj9;
19664     }
19665     {
19666         PyThreadState* __tstate = wxPyBeginAllowThreads();
19667         result = (wxToolBarToolBase *)wxToolBarBase_DoInsertTool(arg1,arg2,arg3,(wxString const &)*arg4,(wxBitmap const &)*arg5,(wxBitmap const &)*arg6,(wxItemKind )arg7,(wxString const &)*arg8,(wxString const &)*arg9,arg10);
19668
19669         wxPyEndAllowThreads(__tstate);
19670         if (PyErr_Occurred()) SWIG_fail;
19671     }
19672     {
19673         resultobj = wxPyMake_wxObject(result, 0);
19674     }
19675     {
19676         if (temp4)
19677         delete arg4;
19678     }
19679     {
19680         if (temp8)
19681         delete arg8;
19682     }
19683     {
19684         if (temp9)
19685         delete arg9;
19686     }
19687     return resultobj;
19688     fail:
19689     {
19690         if (temp4)
19691         delete arg4;
19692     }
19693     {
19694         if (temp8)
19695         delete arg8;
19696     }
19697     {
19698         if (temp9)
19699         delete arg9;
19700     }
19701     return NULL;
19702 }
19703
19704
19705 static PyObject *_wrap_ToolBarBase_AddToolItem(PyObject *, PyObject *args, PyObject *kwargs) {
19706     PyObject *resultobj;
19707     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19708     wxToolBarToolBase *arg2 = (wxToolBarToolBase *) 0 ;
19709     wxToolBarToolBase *result;
19710     PyObject * obj0 = 0 ;
19711     PyObject * obj1 = 0 ;
19712     char *kwnames[] = {
19713         (char *) "self",(char *) "tool", NULL
19714     };
19715
19716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddToolItem",kwnames,&obj0,&obj1)) goto fail;
19717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19718     if (SWIG_arg_fail(1)) SWIG_fail;
19719     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19720     if (SWIG_arg_fail(2)) SWIG_fail;
19721     {
19722         PyThreadState* __tstate = wxPyBeginAllowThreads();
19723         result = (wxToolBarToolBase *)(arg1)->AddTool(arg2);
19724
19725         wxPyEndAllowThreads(__tstate);
19726         if (PyErr_Occurred()) SWIG_fail;
19727     }
19728     {
19729         resultobj = wxPyMake_wxObject(result, 0);
19730     }
19731     return resultobj;
19732     fail:
19733     return NULL;
19734 }
19735
19736
19737 static PyObject *_wrap_ToolBarBase_InsertToolItem(PyObject *, PyObject *args, PyObject *kwargs) {
19738     PyObject *resultobj;
19739     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19740     size_t arg2 ;
19741     wxToolBarToolBase *arg3 = (wxToolBarToolBase *) 0 ;
19742     wxToolBarToolBase *result;
19743     PyObject * obj0 = 0 ;
19744     PyObject * obj1 = 0 ;
19745     PyObject * obj2 = 0 ;
19746     char *kwnames[] = {
19747         (char *) "self",(char *) "pos",(char *) "tool", NULL
19748     };
19749
19750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertToolItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
19751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19752     if (SWIG_arg_fail(1)) SWIG_fail;
19753     {
19754         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19755         if (SWIG_arg_fail(2)) SWIG_fail;
19756     }
19757     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19758     if (SWIG_arg_fail(3)) SWIG_fail;
19759     {
19760         PyThreadState* __tstate = wxPyBeginAllowThreads();
19761         result = (wxToolBarToolBase *)(arg1)->InsertTool(arg2,arg3);
19762
19763         wxPyEndAllowThreads(__tstate);
19764         if (PyErr_Occurred()) SWIG_fail;
19765     }
19766     {
19767         resultobj = wxPyMake_wxObject(result, 0);
19768     }
19769     return resultobj;
19770     fail:
19771     return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_ToolBarBase_AddControl(PyObject *, PyObject *args, PyObject *kwargs) {
19776     PyObject *resultobj;
19777     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19778     wxControl *arg2 = (wxControl *) 0 ;
19779     wxToolBarToolBase *result;
19780     PyObject * obj0 = 0 ;
19781     PyObject * obj1 = 0 ;
19782     char *kwnames[] = {
19783         (char *) "self",(char *) "control", NULL
19784     };
19785
19786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddControl",kwnames,&obj0,&obj1)) goto fail;
19787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19788     if (SWIG_arg_fail(1)) SWIG_fail;
19789     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
19790     if (SWIG_arg_fail(2)) SWIG_fail;
19791     {
19792         PyThreadState* __tstate = wxPyBeginAllowThreads();
19793         result = (wxToolBarToolBase *)(arg1)->AddControl(arg2);
19794
19795         wxPyEndAllowThreads(__tstate);
19796         if (PyErr_Occurred()) SWIG_fail;
19797     }
19798     {
19799         resultobj = wxPyMake_wxObject(result, 0);
19800     }
19801     return resultobj;
19802     fail:
19803     return NULL;
19804 }
19805
19806
19807 static PyObject *_wrap_ToolBarBase_InsertControl(PyObject *, PyObject *args, PyObject *kwargs) {
19808     PyObject *resultobj;
19809     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19810     size_t arg2 ;
19811     wxControl *arg3 = (wxControl *) 0 ;
19812     wxToolBarToolBase *result;
19813     PyObject * obj0 = 0 ;
19814     PyObject * obj1 = 0 ;
19815     PyObject * obj2 = 0 ;
19816     char *kwnames[] = {
19817         (char *) "self",(char *) "pos",(char *) "control", NULL
19818     };
19819
19820     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertControl",kwnames,&obj0,&obj1,&obj2)) goto fail;
19821     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19822     if (SWIG_arg_fail(1)) SWIG_fail;
19823     {
19824         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19825         if (SWIG_arg_fail(2)) SWIG_fail;
19826     }
19827     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
19828     if (SWIG_arg_fail(3)) SWIG_fail;
19829     {
19830         PyThreadState* __tstate = wxPyBeginAllowThreads();
19831         result = (wxToolBarToolBase *)(arg1)->InsertControl(arg2,arg3);
19832
19833         wxPyEndAllowThreads(__tstate);
19834         if (PyErr_Occurred()) SWIG_fail;
19835     }
19836     {
19837         resultobj = wxPyMake_wxObject(result, 0);
19838     }
19839     return resultobj;
19840     fail:
19841     return NULL;
19842 }
19843
19844
19845 static PyObject *_wrap_ToolBarBase_FindControl(PyObject *, PyObject *args, PyObject *kwargs) {
19846     PyObject *resultobj;
19847     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19848     int arg2 ;
19849     wxControl *result;
19850     PyObject * obj0 = 0 ;
19851     PyObject * obj1 = 0 ;
19852     char *kwnames[] = {
19853         (char *) "self",(char *) "id", NULL
19854     };
19855
19856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindControl",kwnames,&obj0,&obj1)) goto fail;
19857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19858     if (SWIG_arg_fail(1)) SWIG_fail;
19859     {
19860         arg2 = (int)(SWIG_As_int(obj1));
19861         if (SWIG_arg_fail(2)) SWIG_fail;
19862     }
19863     {
19864         PyThreadState* __tstate = wxPyBeginAllowThreads();
19865         result = (wxControl *)(arg1)->FindControl(arg2);
19866
19867         wxPyEndAllowThreads(__tstate);
19868         if (PyErr_Occurred()) SWIG_fail;
19869     }
19870     {
19871         resultobj = wxPyMake_wxObject(result, 0);
19872     }
19873     return resultobj;
19874     fail:
19875     return NULL;
19876 }
19877
19878
19879 static PyObject *_wrap_ToolBarBase_AddSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
19880     PyObject *resultobj;
19881     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19882     wxToolBarToolBase *result;
19883     PyObject * obj0 = 0 ;
19884     char *kwnames[] = {
19885         (char *) "self", NULL
19886     };
19887
19888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_AddSeparator",kwnames,&obj0)) goto fail;
19889     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19890     if (SWIG_arg_fail(1)) SWIG_fail;
19891     {
19892         PyThreadState* __tstate = wxPyBeginAllowThreads();
19893         result = (wxToolBarToolBase *)(arg1)->AddSeparator();
19894
19895         wxPyEndAllowThreads(__tstate);
19896         if (PyErr_Occurred()) SWIG_fail;
19897     }
19898     {
19899         resultobj = wxPyMake_wxObject(result, 0);
19900     }
19901     return resultobj;
19902     fail:
19903     return NULL;
19904 }
19905
19906
19907 static PyObject *_wrap_ToolBarBase_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
19908     PyObject *resultobj;
19909     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19910     size_t arg2 ;
19911     wxToolBarToolBase *result;
19912     PyObject * obj0 = 0 ;
19913     PyObject * obj1 = 0 ;
19914     char *kwnames[] = {
19915         (char *) "self",(char *) "pos", NULL
19916     };
19917
19918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
19919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19920     if (SWIG_arg_fail(1)) SWIG_fail;
19921     {
19922         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19923         if (SWIG_arg_fail(2)) SWIG_fail;
19924     }
19925     {
19926         PyThreadState* __tstate = wxPyBeginAllowThreads();
19927         result = (wxToolBarToolBase *)(arg1)->InsertSeparator(arg2);
19928
19929         wxPyEndAllowThreads(__tstate);
19930         if (PyErr_Occurred()) SWIG_fail;
19931     }
19932     {
19933         resultobj = wxPyMake_wxObject(result, 0);
19934     }
19935     return resultobj;
19936     fail:
19937     return NULL;
19938 }
19939
19940
19941 static PyObject *_wrap_ToolBarBase_RemoveTool(PyObject *, PyObject *args, PyObject *kwargs) {
19942     PyObject *resultobj;
19943     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19944     int arg2 ;
19945     wxToolBarToolBase *result;
19946     PyObject * obj0 = 0 ;
19947     PyObject * obj1 = 0 ;
19948     char *kwnames[] = {
19949         (char *) "self",(char *) "id", NULL
19950     };
19951
19952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_RemoveTool",kwnames,&obj0,&obj1)) goto fail;
19953     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19954     if (SWIG_arg_fail(1)) SWIG_fail;
19955     {
19956         arg2 = (int)(SWIG_As_int(obj1));
19957         if (SWIG_arg_fail(2)) SWIG_fail;
19958     }
19959     {
19960         PyThreadState* __tstate = wxPyBeginAllowThreads();
19961         result = (wxToolBarToolBase *)(arg1)->RemoveTool(arg2);
19962
19963         wxPyEndAllowThreads(__tstate);
19964         if (PyErr_Occurred()) SWIG_fail;
19965     }
19966     {
19967         resultobj = wxPyMake_wxObject(result, 0);
19968     }
19969     return resultobj;
19970     fail:
19971     return NULL;
19972 }
19973
19974
19975 static PyObject *_wrap_ToolBarBase_DeleteToolByPos(PyObject *, PyObject *args, PyObject *kwargs) {
19976     PyObject *resultobj;
19977     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19978     size_t arg2 ;
19979     bool result;
19980     PyObject * obj0 = 0 ;
19981     PyObject * obj1 = 0 ;
19982     char *kwnames[] = {
19983         (char *) "self",(char *) "pos", NULL
19984     };
19985
19986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteToolByPos",kwnames,&obj0,&obj1)) goto fail;
19987     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19988     if (SWIG_arg_fail(1)) SWIG_fail;
19989     {
19990         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19991         if (SWIG_arg_fail(2)) SWIG_fail;
19992     }
19993     {
19994         PyThreadState* __tstate = wxPyBeginAllowThreads();
19995         result = (bool)(arg1)->DeleteToolByPos(arg2);
19996
19997         wxPyEndAllowThreads(__tstate);
19998         if (PyErr_Occurred()) SWIG_fail;
19999     }
20000     {
20001         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20002     }
20003     return resultobj;
20004     fail:
20005     return NULL;
20006 }
20007
20008
20009 static PyObject *_wrap_ToolBarBase_DeleteTool(PyObject *, PyObject *args, PyObject *kwargs) {
20010     PyObject *resultobj;
20011     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20012     int arg2 ;
20013     bool result;
20014     PyObject * obj0 = 0 ;
20015     PyObject * obj1 = 0 ;
20016     char *kwnames[] = {
20017         (char *) "self",(char *) "id", NULL
20018     };
20019
20020     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteTool",kwnames,&obj0,&obj1)) goto fail;
20021     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20022     if (SWIG_arg_fail(1)) SWIG_fail;
20023     {
20024         arg2 = (int)(SWIG_As_int(obj1));
20025         if (SWIG_arg_fail(2)) SWIG_fail;
20026     }
20027     {
20028         PyThreadState* __tstate = wxPyBeginAllowThreads();
20029         result = (bool)(arg1)->DeleteTool(arg2);
20030
20031         wxPyEndAllowThreads(__tstate);
20032         if (PyErr_Occurred()) SWIG_fail;
20033     }
20034     {
20035         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20036     }
20037     return resultobj;
20038     fail:
20039     return NULL;
20040 }
20041
20042
20043 static PyObject *_wrap_ToolBarBase_ClearTools(PyObject *, PyObject *args, PyObject *kwargs) {
20044     PyObject *resultobj;
20045     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20046     PyObject * obj0 = 0 ;
20047     char *kwnames[] = {
20048         (char *) "self", NULL
20049     };
20050
20051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_ClearTools",kwnames,&obj0)) goto fail;
20052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20053     if (SWIG_arg_fail(1)) SWIG_fail;
20054     {
20055         PyThreadState* __tstate = wxPyBeginAllowThreads();
20056         (arg1)->ClearTools();
20057
20058         wxPyEndAllowThreads(__tstate);
20059         if (PyErr_Occurred()) SWIG_fail;
20060     }
20061     Py_INCREF(Py_None); resultobj = Py_None;
20062     return resultobj;
20063     fail:
20064     return NULL;
20065 }
20066
20067
20068 static PyObject *_wrap_ToolBarBase_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
20069     PyObject *resultobj;
20070     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20071     bool result;
20072     PyObject * obj0 = 0 ;
20073     char *kwnames[] = {
20074         (char *) "self", NULL
20075     };
20076
20077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_Realize",kwnames,&obj0)) goto fail;
20078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20079     if (SWIG_arg_fail(1)) SWIG_fail;
20080     {
20081         PyThreadState* __tstate = wxPyBeginAllowThreads();
20082         result = (bool)(arg1)->Realize();
20083
20084         wxPyEndAllowThreads(__tstate);
20085         if (PyErr_Occurred()) SWIG_fail;
20086     }
20087     {
20088         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20089     }
20090     return resultobj;
20091     fail:
20092     return NULL;
20093 }
20094
20095
20096 static PyObject *_wrap_ToolBarBase_EnableTool(PyObject *, PyObject *args, PyObject *kwargs) {
20097     PyObject *resultobj;
20098     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20099     int arg2 ;
20100     bool arg3 ;
20101     PyObject * obj0 = 0 ;
20102     PyObject * obj1 = 0 ;
20103     PyObject * obj2 = 0 ;
20104     char *kwnames[] = {
20105         (char *) "self",(char *) "id",(char *) "enable", NULL
20106     };
20107
20108     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_EnableTool",kwnames,&obj0,&obj1,&obj2)) goto fail;
20109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20110     if (SWIG_arg_fail(1)) SWIG_fail;
20111     {
20112         arg2 = (int)(SWIG_As_int(obj1));
20113         if (SWIG_arg_fail(2)) SWIG_fail;
20114     }
20115     {
20116         arg3 = (bool)(SWIG_As_bool(obj2));
20117         if (SWIG_arg_fail(3)) SWIG_fail;
20118     }
20119     {
20120         PyThreadState* __tstate = wxPyBeginAllowThreads();
20121         (arg1)->EnableTool(arg2,arg3);
20122
20123         wxPyEndAllowThreads(__tstate);
20124         if (PyErr_Occurred()) SWIG_fail;
20125     }
20126     Py_INCREF(Py_None); resultobj = Py_None;
20127     return resultobj;
20128     fail:
20129     return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_ToolBarBase_ToggleTool(PyObject *, PyObject *args, PyObject *kwargs) {
20134     PyObject *resultobj;
20135     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20136     int arg2 ;
20137     bool arg3 ;
20138     PyObject * obj0 = 0 ;
20139     PyObject * obj1 = 0 ;
20140     PyObject * obj2 = 0 ;
20141     char *kwnames[] = {
20142         (char *) "self",(char *) "id",(char *) "toggle", NULL
20143     };
20144
20145     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_ToggleTool",kwnames,&obj0,&obj1,&obj2)) goto fail;
20146     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20147     if (SWIG_arg_fail(1)) SWIG_fail;
20148     {
20149         arg2 = (int)(SWIG_As_int(obj1));
20150         if (SWIG_arg_fail(2)) SWIG_fail;
20151     }
20152     {
20153         arg3 = (bool)(SWIG_As_bool(obj2));
20154         if (SWIG_arg_fail(3)) SWIG_fail;
20155     }
20156     {
20157         PyThreadState* __tstate = wxPyBeginAllowThreads();
20158         (arg1)->ToggleTool(arg2,arg3);
20159
20160         wxPyEndAllowThreads(__tstate);
20161         if (PyErr_Occurred()) SWIG_fail;
20162     }
20163     Py_INCREF(Py_None); resultobj = Py_None;
20164     return resultobj;
20165     fail:
20166     return NULL;
20167 }
20168
20169
20170 static PyObject *_wrap_ToolBarBase_SetToggle(PyObject *, PyObject *args, PyObject *kwargs) {
20171     PyObject *resultobj;
20172     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20173     int arg2 ;
20174     bool arg3 ;
20175     PyObject * obj0 = 0 ;
20176     PyObject * obj1 = 0 ;
20177     PyObject * obj2 = 0 ;
20178     char *kwnames[] = {
20179         (char *) "self",(char *) "id",(char *) "toggle", NULL
20180     };
20181
20182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToggle",kwnames,&obj0,&obj1,&obj2)) goto fail;
20183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20184     if (SWIG_arg_fail(1)) SWIG_fail;
20185     {
20186         arg2 = (int)(SWIG_As_int(obj1));
20187         if (SWIG_arg_fail(2)) SWIG_fail;
20188     }
20189     {
20190         arg3 = (bool)(SWIG_As_bool(obj2));
20191         if (SWIG_arg_fail(3)) SWIG_fail;
20192     }
20193     {
20194         PyThreadState* __tstate = wxPyBeginAllowThreads();
20195         (arg1)->SetToggle(arg2,arg3);
20196
20197         wxPyEndAllowThreads(__tstate);
20198         if (PyErr_Occurred()) SWIG_fail;
20199     }
20200     Py_INCREF(Py_None); resultobj = Py_None;
20201     return resultobj;
20202     fail:
20203     return NULL;
20204 }
20205
20206
20207 static PyObject *_wrap_ToolBarBase_GetToolClientData(PyObject *, PyObject *args, PyObject *kwargs) {
20208     PyObject *resultobj;
20209     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20210     int arg2 ;
20211     PyObject *result;
20212     PyObject * obj0 = 0 ;
20213     PyObject * obj1 = 0 ;
20214     char *kwnames[] = {
20215         (char *) "self",(char *) "id", NULL
20216     };
20217
20218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolClientData",kwnames,&obj0,&obj1)) goto fail;
20219     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20220     if (SWIG_arg_fail(1)) SWIG_fail;
20221     {
20222         arg2 = (int)(SWIG_As_int(obj1));
20223         if (SWIG_arg_fail(2)) SWIG_fail;
20224     }
20225     {
20226         PyThreadState* __tstate = wxPyBeginAllowThreads();
20227         result = (PyObject *)wxToolBarBase_GetToolClientData(arg1,arg2);
20228
20229         wxPyEndAllowThreads(__tstate);
20230         if (PyErr_Occurred()) SWIG_fail;
20231     }
20232     resultobj = result;
20233     return resultobj;
20234     fail:
20235     return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_ToolBarBase_SetToolClientData(PyObject *, PyObject *args, PyObject *kwargs) {
20240     PyObject *resultobj;
20241     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20242     int arg2 ;
20243     PyObject *arg3 = (PyObject *) 0 ;
20244     PyObject * obj0 = 0 ;
20245     PyObject * obj1 = 0 ;
20246     PyObject * obj2 = 0 ;
20247     char *kwnames[] = {
20248         (char *) "self",(char *) "id",(char *) "clientData", NULL
20249     };
20250
20251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
20252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20253     if (SWIG_arg_fail(1)) SWIG_fail;
20254     {
20255         arg2 = (int)(SWIG_As_int(obj1));
20256         if (SWIG_arg_fail(2)) SWIG_fail;
20257     }
20258     arg3 = obj2;
20259     {
20260         PyThreadState* __tstate = wxPyBeginAllowThreads();
20261         wxToolBarBase_SetToolClientData(arg1,arg2,arg3);
20262
20263         wxPyEndAllowThreads(__tstate);
20264         if (PyErr_Occurred()) SWIG_fail;
20265     }
20266     Py_INCREF(Py_None); resultobj = Py_None;
20267     return resultobj;
20268     fail:
20269     return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_ToolBarBase_GetToolPos(PyObject *, PyObject *args, PyObject *kwargs) {
20274     PyObject *resultobj;
20275     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20276     int arg2 ;
20277     int result;
20278     PyObject * obj0 = 0 ;
20279     PyObject * obj1 = 0 ;
20280     char *kwnames[] = {
20281         (char *) "self",(char *) "id", NULL
20282     };
20283
20284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolPos",kwnames,&obj0,&obj1)) goto fail;
20285     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20286     if (SWIG_arg_fail(1)) SWIG_fail;
20287     {
20288         arg2 = (int)(SWIG_As_int(obj1));
20289         if (SWIG_arg_fail(2)) SWIG_fail;
20290     }
20291     {
20292         PyThreadState* __tstate = wxPyBeginAllowThreads();
20293         result = (int)((wxToolBarBase const *)arg1)->GetToolPos(arg2);
20294
20295         wxPyEndAllowThreads(__tstate);
20296         if (PyErr_Occurred()) SWIG_fail;
20297     }
20298     {
20299         resultobj = SWIG_From_int((int)(result));
20300     }
20301     return resultobj;
20302     fail:
20303     return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_ToolBarBase_GetToolState(PyObject *, PyObject *args, PyObject *kwargs) {
20308     PyObject *resultobj;
20309     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20310     int arg2 ;
20311     bool result;
20312     PyObject * obj0 = 0 ;
20313     PyObject * obj1 = 0 ;
20314     char *kwnames[] = {
20315         (char *) "self",(char *) "id", NULL
20316     };
20317
20318     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolState",kwnames,&obj0,&obj1)) goto fail;
20319     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20320     if (SWIG_arg_fail(1)) SWIG_fail;
20321     {
20322         arg2 = (int)(SWIG_As_int(obj1));
20323         if (SWIG_arg_fail(2)) SWIG_fail;
20324     }
20325     {
20326         PyThreadState* __tstate = wxPyBeginAllowThreads();
20327         result = (bool)(arg1)->GetToolState(arg2);
20328
20329         wxPyEndAllowThreads(__tstate);
20330         if (PyErr_Occurred()) SWIG_fail;
20331     }
20332     {
20333         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20334     }
20335     return resultobj;
20336     fail:
20337     return NULL;
20338 }
20339
20340
20341 static PyObject *_wrap_ToolBarBase_GetToolEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20342     PyObject *resultobj;
20343     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20344     int arg2 ;
20345     bool result;
20346     PyObject * obj0 = 0 ;
20347     PyObject * obj1 = 0 ;
20348     char *kwnames[] = {
20349         (char *) "self",(char *) "id", NULL
20350     };
20351
20352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolEnabled",kwnames,&obj0,&obj1)) goto fail;
20353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20354     if (SWIG_arg_fail(1)) SWIG_fail;
20355     {
20356         arg2 = (int)(SWIG_As_int(obj1));
20357         if (SWIG_arg_fail(2)) SWIG_fail;
20358     }
20359     {
20360         PyThreadState* __tstate = wxPyBeginAllowThreads();
20361         result = (bool)(arg1)->GetToolEnabled(arg2);
20362
20363         wxPyEndAllowThreads(__tstate);
20364         if (PyErr_Occurred()) SWIG_fail;
20365     }
20366     {
20367         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20368     }
20369     return resultobj;
20370     fail:
20371     return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_ToolBarBase_SetToolShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20376     PyObject *resultobj;
20377     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20378     int arg2 ;
20379     wxString *arg3 = 0 ;
20380     bool temp3 = false ;
20381     PyObject * obj0 = 0 ;
20382     PyObject * obj1 = 0 ;
20383     PyObject * obj2 = 0 ;
20384     char *kwnames[] = {
20385         (char *) "self",(char *) "id",(char *) "helpString", NULL
20386     };
20387
20388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolShortHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
20389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20390     if (SWIG_arg_fail(1)) SWIG_fail;
20391     {
20392         arg2 = (int)(SWIG_As_int(obj1));
20393         if (SWIG_arg_fail(2)) SWIG_fail;
20394     }
20395     {
20396         arg3 = wxString_in_helper(obj2);
20397         if (arg3 == NULL) SWIG_fail;
20398         temp3 = true;
20399     }
20400     {
20401         PyThreadState* __tstate = wxPyBeginAllowThreads();
20402         (arg1)->SetToolShortHelp(arg2,(wxString const &)*arg3);
20403
20404         wxPyEndAllowThreads(__tstate);
20405         if (PyErr_Occurred()) SWIG_fail;
20406     }
20407     Py_INCREF(Py_None); resultobj = Py_None;
20408     {
20409         if (temp3)
20410         delete arg3;
20411     }
20412     return resultobj;
20413     fail:
20414     {
20415         if (temp3)
20416         delete arg3;
20417     }
20418     return NULL;
20419 }
20420
20421
20422 static PyObject *_wrap_ToolBarBase_GetToolShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20423     PyObject *resultobj;
20424     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20425     int arg2 ;
20426     wxString result;
20427     PyObject * obj0 = 0 ;
20428     PyObject * obj1 = 0 ;
20429     char *kwnames[] = {
20430         (char *) "self",(char *) "id", NULL
20431     };
20432
20433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolShortHelp",kwnames,&obj0,&obj1)) goto fail;
20434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20435     if (SWIG_arg_fail(1)) SWIG_fail;
20436     {
20437         arg2 = (int)(SWIG_As_int(obj1));
20438         if (SWIG_arg_fail(2)) SWIG_fail;
20439     }
20440     {
20441         PyThreadState* __tstate = wxPyBeginAllowThreads();
20442         result = (arg1)->GetToolShortHelp(arg2);
20443
20444         wxPyEndAllowThreads(__tstate);
20445         if (PyErr_Occurred()) SWIG_fail;
20446     }
20447     {
20448 #if wxUSE_UNICODE
20449         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20450 #else
20451         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20452 #endif
20453     }
20454     return resultobj;
20455     fail:
20456     return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_ToolBarBase_SetToolLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20461     PyObject *resultobj;
20462     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20463     int arg2 ;
20464     wxString *arg3 = 0 ;
20465     bool temp3 = false ;
20466     PyObject * obj0 = 0 ;
20467     PyObject * obj1 = 0 ;
20468     PyObject * obj2 = 0 ;
20469     char *kwnames[] = {
20470         (char *) "self",(char *) "id",(char *) "helpString", NULL
20471     };
20472
20473     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolLongHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
20474     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20475     if (SWIG_arg_fail(1)) SWIG_fail;
20476     {
20477         arg2 = (int)(SWIG_As_int(obj1));
20478         if (SWIG_arg_fail(2)) SWIG_fail;
20479     }
20480     {
20481         arg3 = wxString_in_helper(obj2);
20482         if (arg3 == NULL) SWIG_fail;
20483         temp3 = true;
20484     }
20485     {
20486         PyThreadState* __tstate = wxPyBeginAllowThreads();
20487         (arg1)->SetToolLongHelp(arg2,(wxString const &)*arg3);
20488
20489         wxPyEndAllowThreads(__tstate);
20490         if (PyErr_Occurred()) SWIG_fail;
20491     }
20492     Py_INCREF(Py_None); resultobj = Py_None;
20493     {
20494         if (temp3)
20495         delete arg3;
20496     }
20497     return resultobj;
20498     fail:
20499     {
20500         if (temp3)
20501         delete arg3;
20502     }
20503     return NULL;
20504 }
20505
20506
20507 static PyObject *_wrap_ToolBarBase_GetToolLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20508     PyObject *resultobj;
20509     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20510     int arg2 ;
20511     wxString result;
20512     PyObject * obj0 = 0 ;
20513     PyObject * obj1 = 0 ;
20514     char *kwnames[] = {
20515         (char *) "self",(char *) "id", NULL
20516     };
20517
20518     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolLongHelp",kwnames,&obj0,&obj1)) goto fail;
20519     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20520     if (SWIG_arg_fail(1)) SWIG_fail;
20521     {
20522         arg2 = (int)(SWIG_As_int(obj1));
20523         if (SWIG_arg_fail(2)) SWIG_fail;
20524     }
20525     {
20526         PyThreadState* __tstate = wxPyBeginAllowThreads();
20527         result = (arg1)->GetToolLongHelp(arg2);
20528
20529         wxPyEndAllowThreads(__tstate);
20530         if (PyErr_Occurred()) SWIG_fail;
20531     }
20532     {
20533 #if wxUSE_UNICODE
20534         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20535 #else
20536         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20537 #endif
20538     }
20539     return resultobj;
20540     fail:
20541     return NULL;
20542 }
20543
20544
20545 static PyObject *_wrap_ToolBarBase_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
20546     PyObject *resultobj;
20547     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20548     int arg2 ;
20549     int arg3 ;
20550     PyObject * obj0 = 0 ;
20551     PyObject * obj1 = 0 ;
20552     PyObject * obj2 = 0 ;
20553     char *kwnames[] = {
20554         (char *) "self",(char *) "x",(char *) "y", NULL
20555     };
20556
20557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
20558     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20559     if (SWIG_arg_fail(1)) SWIG_fail;
20560     {
20561         arg2 = (int)(SWIG_As_int(obj1));
20562         if (SWIG_arg_fail(2)) SWIG_fail;
20563     }
20564     {
20565         arg3 = (int)(SWIG_As_int(obj2));
20566         if (SWIG_arg_fail(3)) SWIG_fail;
20567     }
20568     {
20569         PyThreadState* __tstate = wxPyBeginAllowThreads();
20570         (arg1)->SetMargins(arg2,arg3);
20571
20572         wxPyEndAllowThreads(__tstate);
20573         if (PyErr_Occurred()) SWIG_fail;
20574     }
20575     Py_INCREF(Py_None); resultobj = Py_None;
20576     return resultobj;
20577     fail:
20578     return NULL;
20579 }
20580
20581
20582 static PyObject *_wrap_ToolBarBase_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20583     PyObject *resultobj;
20584     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20585     wxSize *arg2 = 0 ;
20586     wxSize temp2 ;
20587     PyObject * obj0 = 0 ;
20588     PyObject * obj1 = 0 ;
20589     char *kwnames[] = {
20590         (char *) "self",(char *) "size", NULL
20591     };
20592
20593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetMargins",kwnames,&obj0,&obj1)) goto fail;
20594     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20595     if (SWIG_arg_fail(1)) SWIG_fail;
20596     {
20597         arg2 = &temp2;
20598         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20599     }
20600     {
20601         PyThreadState* __tstate = wxPyBeginAllowThreads();
20602         (arg1)->SetMargins((wxSize const &)*arg2);
20603
20604         wxPyEndAllowThreads(__tstate);
20605         if (PyErr_Occurred()) SWIG_fail;
20606     }
20607     Py_INCREF(Py_None); resultobj = Py_None;
20608     return resultobj;
20609     fail:
20610     return NULL;
20611 }
20612
20613
20614 static PyObject *_wrap_ToolBarBase_SetToolPacking(PyObject *, PyObject *args, PyObject *kwargs) {
20615     PyObject *resultobj;
20616     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20617     int arg2 ;
20618     PyObject * obj0 = 0 ;
20619     PyObject * obj1 = 0 ;
20620     char *kwnames[] = {
20621         (char *) "self",(char *) "packing", NULL
20622     };
20623
20624     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolPacking",kwnames,&obj0,&obj1)) goto fail;
20625     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20626     if (SWIG_arg_fail(1)) SWIG_fail;
20627     {
20628         arg2 = (int)(SWIG_As_int(obj1));
20629         if (SWIG_arg_fail(2)) SWIG_fail;
20630     }
20631     {
20632         PyThreadState* __tstate = wxPyBeginAllowThreads();
20633         (arg1)->SetToolPacking(arg2);
20634
20635         wxPyEndAllowThreads(__tstate);
20636         if (PyErr_Occurred()) SWIG_fail;
20637     }
20638     Py_INCREF(Py_None); resultobj = Py_None;
20639     return resultobj;
20640     fail:
20641     return NULL;
20642 }
20643
20644
20645 static PyObject *_wrap_ToolBarBase_SetToolSeparation(PyObject *, PyObject *args, PyObject *kwargs) {
20646     PyObject *resultobj;
20647     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20648     int arg2 ;
20649     PyObject * obj0 = 0 ;
20650     PyObject * obj1 = 0 ;
20651     char *kwnames[] = {
20652         (char *) "self",(char *) "separation", NULL
20653     };
20654
20655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolSeparation",kwnames,&obj0,&obj1)) goto fail;
20656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20657     if (SWIG_arg_fail(1)) SWIG_fail;
20658     {
20659         arg2 = (int)(SWIG_As_int(obj1));
20660         if (SWIG_arg_fail(2)) SWIG_fail;
20661     }
20662     {
20663         PyThreadState* __tstate = wxPyBeginAllowThreads();
20664         (arg1)->SetToolSeparation(arg2);
20665
20666         wxPyEndAllowThreads(__tstate);
20667         if (PyErr_Occurred()) SWIG_fail;
20668     }
20669     Py_INCREF(Py_None); resultobj = Py_None;
20670     return resultobj;
20671     fail:
20672     return NULL;
20673 }
20674
20675
20676 static PyObject *_wrap_ToolBarBase_GetToolMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20677     PyObject *resultobj;
20678     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20679     wxSize result;
20680     PyObject * obj0 = 0 ;
20681     char *kwnames[] = {
20682         (char *) "self", NULL
20683     };
20684
20685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolMargins",kwnames,&obj0)) goto fail;
20686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20687     if (SWIG_arg_fail(1)) SWIG_fail;
20688     {
20689         PyThreadState* __tstate = wxPyBeginAllowThreads();
20690         result = (arg1)->GetToolMargins();
20691
20692         wxPyEndAllowThreads(__tstate);
20693         if (PyErr_Occurred()) SWIG_fail;
20694     }
20695     {
20696         wxSize * resultptr;
20697         resultptr = new wxSize((wxSize &)(result));
20698         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20699     }
20700     return resultobj;
20701     fail:
20702     return NULL;
20703 }
20704
20705
20706 static PyObject *_wrap_ToolBarBase_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20707     PyObject *resultobj;
20708     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20709     wxSize result;
20710     PyObject * obj0 = 0 ;
20711     char *kwnames[] = {
20712         (char *) "self", NULL
20713     };
20714
20715     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMargins",kwnames,&obj0)) goto fail;
20716     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20717     if (SWIG_arg_fail(1)) SWIG_fail;
20718     {
20719         PyThreadState* __tstate = wxPyBeginAllowThreads();
20720         result = (arg1)->GetMargins();
20721
20722         wxPyEndAllowThreads(__tstate);
20723         if (PyErr_Occurred()) SWIG_fail;
20724     }
20725     {
20726         wxSize * resultptr;
20727         resultptr = new wxSize((wxSize &)(result));
20728         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20729     }
20730     return resultobj;
20731     fail:
20732     return NULL;
20733 }
20734
20735
20736 static PyObject *_wrap_ToolBarBase_GetToolPacking(PyObject *, PyObject *args, PyObject *kwargs) {
20737     PyObject *resultobj;
20738     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20739     int result;
20740     PyObject * obj0 = 0 ;
20741     char *kwnames[] = {
20742         (char *) "self", NULL
20743     };
20744
20745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolPacking",kwnames,&obj0)) goto fail;
20746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20747     if (SWIG_arg_fail(1)) SWIG_fail;
20748     {
20749         PyThreadState* __tstate = wxPyBeginAllowThreads();
20750         result = (int)(arg1)->GetToolPacking();
20751
20752         wxPyEndAllowThreads(__tstate);
20753         if (PyErr_Occurred()) SWIG_fail;
20754     }
20755     {
20756         resultobj = SWIG_From_int((int)(result));
20757     }
20758     return resultobj;
20759     fail:
20760     return NULL;
20761 }
20762
20763
20764 static PyObject *_wrap_ToolBarBase_GetToolSeparation(PyObject *, PyObject *args, PyObject *kwargs) {
20765     PyObject *resultobj;
20766     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20767     int result;
20768     PyObject * obj0 = 0 ;
20769     char *kwnames[] = {
20770         (char *) "self", NULL
20771     };
20772
20773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolSeparation",kwnames,&obj0)) goto fail;
20774     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20775     if (SWIG_arg_fail(1)) SWIG_fail;
20776     {
20777         PyThreadState* __tstate = wxPyBeginAllowThreads();
20778         result = (int)(arg1)->GetToolSeparation();
20779
20780         wxPyEndAllowThreads(__tstate);
20781         if (PyErr_Occurred()) SWIG_fail;
20782     }
20783     {
20784         resultobj = SWIG_From_int((int)(result));
20785     }
20786     return resultobj;
20787     fail:
20788     return NULL;
20789 }
20790
20791
20792 static PyObject *_wrap_ToolBarBase_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
20793     PyObject *resultobj;
20794     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20795     int arg2 ;
20796     PyObject * obj0 = 0 ;
20797     PyObject * obj1 = 0 ;
20798     char *kwnames[] = {
20799         (char *) "self",(char *) "nRows", NULL
20800     };
20801
20802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetRows",kwnames,&obj0,&obj1)) goto fail;
20803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20804     if (SWIG_arg_fail(1)) SWIG_fail;
20805     {
20806         arg2 = (int)(SWIG_As_int(obj1));
20807         if (SWIG_arg_fail(2)) SWIG_fail;
20808     }
20809     {
20810         PyThreadState* __tstate = wxPyBeginAllowThreads();
20811         (arg1)->SetRows(arg2);
20812
20813         wxPyEndAllowThreads(__tstate);
20814         if (PyErr_Occurred()) SWIG_fail;
20815     }
20816     Py_INCREF(Py_None); resultobj = Py_None;
20817     return resultobj;
20818     fail:
20819     return NULL;
20820 }
20821
20822
20823 static PyObject *_wrap_ToolBarBase_SetMaxRowsCols(PyObject *, PyObject *args, PyObject *kwargs) {
20824     PyObject *resultobj;
20825     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20826     int arg2 ;
20827     int arg3 ;
20828     PyObject * obj0 = 0 ;
20829     PyObject * obj1 = 0 ;
20830     PyObject * obj2 = 0 ;
20831     char *kwnames[] = {
20832         (char *) "self",(char *) "rows",(char *) "cols", NULL
20833     };
20834
20835     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMaxRowsCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
20836     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20837     if (SWIG_arg_fail(1)) SWIG_fail;
20838     {
20839         arg2 = (int)(SWIG_As_int(obj1));
20840         if (SWIG_arg_fail(2)) SWIG_fail;
20841     }
20842     {
20843         arg3 = (int)(SWIG_As_int(obj2));
20844         if (SWIG_arg_fail(3)) SWIG_fail;
20845     }
20846     {
20847         PyThreadState* __tstate = wxPyBeginAllowThreads();
20848         (arg1)->SetMaxRowsCols(arg2,arg3);
20849
20850         wxPyEndAllowThreads(__tstate);
20851         if (PyErr_Occurred()) SWIG_fail;
20852     }
20853     Py_INCREF(Py_None); resultobj = Py_None;
20854     return resultobj;
20855     fail:
20856     return NULL;
20857 }
20858
20859
20860 static PyObject *_wrap_ToolBarBase_GetMaxRows(PyObject *, PyObject *args, PyObject *kwargs) {
20861     PyObject *resultobj;
20862     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20863     int result;
20864     PyObject * obj0 = 0 ;
20865     char *kwnames[] = {
20866         (char *) "self", NULL
20867     };
20868
20869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMaxRows",kwnames,&obj0)) goto fail;
20870     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20871     if (SWIG_arg_fail(1)) SWIG_fail;
20872     {
20873         PyThreadState* __tstate = wxPyBeginAllowThreads();
20874         result = (int)(arg1)->GetMaxRows();
20875
20876         wxPyEndAllowThreads(__tstate);
20877         if (PyErr_Occurred()) SWIG_fail;
20878     }
20879     {
20880         resultobj = SWIG_From_int((int)(result));
20881     }
20882     return resultobj;
20883     fail:
20884     return NULL;
20885 }
20886
20887
20888 static PyObject *_wrap_ToolBarBase_GetMaxCols(PyObject *, PyObject *args, PyObject *kwargs) {
20889     PyObject *resultobj;
20890     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20891     int result;
20892     PyObject * obj0 = 0 ;
20893     char *kwnames[] = {
20894         (char *) "self", NULL
20895     };
20896
20897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMaxCols",kwnames,&obj0)) goto fail;
20898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20899     if (SWIG_arg_fail(1)) SWIG_fail;
20900     {
20901         PyThreadState* __tstate = wxPyBeginAllowThreads();
20902         result = (int)(arg1)->GetMaxCols();
20903
20904         wxPyEndAllowThreads(__tstate);
20905         if (PyErr_Occurred()) SWIG_fail;
20906     }
20907     {
20908         resultobj = SWIG_From_int((int)(result));
20909     }
20910     return resultobj;
20911     fail:
20912     return NULL;
20913 }
20914
20915
20916 static PyObject *_wrap_ToolBarBase_SetToolBitmapSize(PyObject *, PyObject *args, PyObject *kwargs) {
20917     PyObject *resultobj;
20918     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20919     wxSize *arg2 = 0 ;
20920     wxSize temp2 ;
20921     PyObject * obj0 = 0 ;
20922     PyObject * obj1 = 0 ;
20923     char *kwnames[] = {
20924         (char *) "self",(char *) "size", NULL
20925     };
20926
20927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolBitmapSize",kwnames,&obj0,&obj1)) goto fail;
20928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20929     if (SWIG_arg_fail(1)) SWIG_fail;
20930     {
20931         arg2 = &temp2;
20932         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20933     }
20934     {
20935         PyThreadState* __tstate = wxPyBeginAllowThreads();
20936         (arg1)->SetToolBitmapSize((wxSize const &)*arg2);
20937
20938         wxPyEndAllowThreads(__tstate);
20939         if (PyErr_Occurred()) SWIG_fail;
20940     }
20941     Py_INCREF(Py_None); resultobj = Py_None;
20942     return resultobj;
20943     fail:
20944     return NULL;
20945 }
20946
20947
20948 static PyObject *_wrap_ToolBarBase_GetToolBitmapSize(PyObject *, PyObject *args, PyObject *kwargs) {
20949     PyObject *resultobj;
20950     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20951     wxSize result;
20952     PyObject * obj0 = 0 ;
20953     char *kwnames[] = {
20954         (char *) "self", NULL
20955     };
20956
20957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolBitmapSize",kwnames,&obj0)) goto fail;
20958     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20959     if (SWIG_arg_fail(1)) SWIG_fail;
20960     {
20961         PyThreadState* __tstate = wxPyBeginAllowThreads();
20962         result = (arg1)->GetToolBitmapSize();
20963
20964         wxPyEndAllowThreads(__tstate);
20965         if (PyErr_Occurred()) SWIG_fail;
20966     }
20967     {
20968         wxSize * resultptr;
20969         resultptr = new wxSize((wxSize &)(result));
20970         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20971     }
20972     return resultobj;
20973     fail:
20974     return NULL;
20975 }
20976
20977
20978 static PyObject *_wrap_ToolBarBase_GetToolSize(PyObject *, PyObject *args, PyObject *kwargs) {
20979     PyObject *resultobj;
20980     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20981     wxSize result;
20982     PyObject * obj0 = 0 ;
20983     char *kwnames[] = {
20984         (char *) "self", NULL
20985     };
20986
20987     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolSize",kwnames,&obj0)) goto fail;
20988     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20989     if (SWIG_arg_fail(1)) SWIG_fail;
20990     {
20991         PyThreadState* __tstate = wxPyBeginAllowThreads();
20992         result = (arg1)->GetToolSize();
20993
20994         wxPyEndAllowThreads(__tstate);
20995         if (PyErr_Occurred()) SWIG_fail;
20996     }
20997     {
20998         wxSize * resultptr;
20999         resultptr = new wxSize((wxSize &)(result));
21000         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
21001     }
21002     return resultobj;
21003     fail:
21004     return NULL;
21005 }
21006
21007
21008 static PyObject *_wrap_ToolBarBase_FindToolForPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21009     PyObject *resultobj;
21010     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21011     int arg2 ;
21012     int arg3 ;
21013     wxToolBarToolBase *result;
21014     PyObject * obj0 = 0 ;
21015     PyObject * obj1 = 0 ;
21016     PyObject * obj2 = 0 ;
21017     char *kwnames[] = {
21018         (char *) "self",(char *) "x",(char *) "y", NULL
21019     };
21020
21021     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_FindToolForPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
21022     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21023     if (SWIG_arg_fail(1)) SWIG_fail;
21024     {
21025         arg2 = (int)(SWIG_As_int(obj1));
21026         if (SWIG_arg_fail(2)) SWIG_fail;
21027     }
21028     {
21029         arg3 = (int)(SWIG_As_int(obj2));
21030         if (SWIG_arg_fail(3)) SWIG_fail;
21031     }
21032     {
21033         PyThreadState* __tstate = wxPyBeginAllowThreads();
21034         result = (wxToolBarToolBase *)(arg1)->FindToolForPosition(arg2,arg3);
21035
21036         wxPyEndAllowThreads(__tstate);
21037         if (PyErr_Occurred()) SWIG_fail;
21038     }
21039     {
21040         resultobj = wxPyMake_wxObject(result, 0);
21041     }
21042     return resultobj;
21043     fail:
21044     return NULL;
21045 }
21046
21047
21048 static PyObject *_wrap_ToolBarBase_FindById(PyObject *, PyObject *args, PyObject *kwargs) {
21049     PyObject *resultobj;
21050     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21051     int arg2 ;
21052     wxToolBarToolBase *result;
21053     PyObject * obj0 = 0 ;
21054     PyObject * obj1 = 0 ;
21055     char *kwnames[] = {
21056         (char *) "self",(char *) "toolid", NULL
21057     };
21058
21059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindById",kwnames,&obj0,&obj1)) goto fail;
21060     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21061     if (SWIG_arg_fail(1)) SWIG_fail;
21062     {
21063         arg2 = (int)(SWIG_As_int(obj1));
21064         if (SWIG_arg_fail(2)) SWIG_fail;
21065     }
21066     {
21067         PyThreadState* __tstate = wxPyBeginAllowThreads();
21068         result = (wxToolBarToolBase *)((wxToolBarBase const *)arg1)->FindById(arg2);
21069
21070         wxPyEndAllowThreads(__tstate);
21071         if (PyErr_Occurred()) SWIG_fail;
21072     }
21073     {
21074         resultobj = wxPyMake_wxObject(result, 0);
21075     }
21076     return resultobj;
21077     fail:
21078     return NULL;
21079 }
21080
21081
21082 static PyObject *_wrap_ToolBarBase_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
21083     PyObject *resultobj;
21084     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21085     bool result;
21086     PyObject * obj0 = 0 ;
21087     char *kwnames[] = {
21088         (char *) "self", NULL
21089     };
21090
21091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_IsVertical",kwnames,&obj0)) goto fail;
21092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21093     if (SWIG_arg_fail(1)) SWIG_fail;
21094     {
21095         PyThreadState* __tstate = wxPyBeginAllowThreads();
21096         result = (bool)(arg1)->IsVertical();
21097
21098         wxPyEndAllowThreads(__tstate);
21099         if (PyErr_Occurred()) SWIG_fail;
21100     }
21101     {
21102         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21103     }
21104     return resultobj;
21105     fail:
21106     return NULL;
21107 }
21108
21109
21110 static PyObject * ToolBarBase_swigregister(PyObject *, PyObject *args) {
21111     PyObject *obj;
21112     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21113     SWIG_TypeClientData(SWIGTYPE_p_wxToolBarBase, obj);
21114     Py_INCREF(obj);
21115     return Py_BuildValue((char *)"");
21116 }
21117 static PyObject *_wrap_new_ToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
21118     PyObject *resultobj;
21119     wxWindow *arg1 = (wxWindow *) 0 ;
21120     int arg2 = (int) -1 ;
21121     wxPoint const &arg3_defvalue = wxDefaultPosition ;
21122     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21123     wxSize const &arg4_defvalue = wxDefaultSize ;
21124     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
21125     long arg5 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
21126     wxString const &arg6_defvalue = wxPyToolBarNameStr ;
21127     wxString *arg6 = (wxString *) &arg6_defvalue ;
21128     wxToolBar *result;
21129     wxPoint temp3 ;
21130     wxSize temp4 ;
21131     bool temp6 = false ;
21132     PyObject * obj0 = 0 ;
21133     PyObject * obj1 = 0 ;
21134     PyObject * obj2 = 0 ;
21135     PyObject * obj3 = 0 ;
21136     PyObject * obj4 = 0 ;
21137     PyObject * obj5 = 0 ;
21138     char *kwnames[] = {
21139         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
21140     };
21141
21142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ToolBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21144     if (SWIG_arg_fail(1)) SWIG_fail;
21145     if (obj1) {
21146         {
21147             arg2 = (int)(SWIG_As_int(obj1));
21148             if (SWIG_arg_fail(2)) SWIG_fail;
21149         }
21150     }
21151     if (obj2) {
21152         {
21153             arg3 = &temp3;
21154             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21155         }
21156     }
21157     if (obj3) {
21158         {
21159             arg4 = &temp4;
21160             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21161         }
21162     }
21163     if (obj4) {
21164         {
21165             arg5 = (long)(SWIG_As_long(obj4));
21166             if (SWIG_arg_fail(5)) SWIG_fail;
21167         }
21168     }
21169     if (obj5) {
21170         {
21171             arg6 = wxString_in_helper(obj5);
21172             if (arg6 == NULL) SWIG_fail;
21173             temp6 = true;
21174         }
21175     }
21176     {
21177         if (!wxPyCheckForApp()) SWIG_fail;
21178         PyThreadState* __tstate = wxPyBeginAllowThreads();
21179         result = (wxToolBar *)new wxToolBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
21180
21181         wxPyEndAllowThreads(__tstate);
21182         if (PyErr_Occurred()) SWIG_fail;
21183     }
21184     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolBar, 1);
21185     {
21186         if (temp6)
21187         delete arg6;
21188     }
21189     return resultobj;
21190     fail:
21191     {
21192         if (temp6)
21193         delete arg6;
21194     }
21195     return NULL;
21196 }
21197
21198
21199 static PyObject *_wrap_new_PreToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
21200     PyObject *resultobj;
21201     wxToolBar *result;
21202     char *kwnames[] = {
21203         NULL
21204     };
21205
21206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreToolBar",kwnames)) goto fail;
21207     {
21208         if (!wxPyCheckForApp()) SWIG_fail;
21209         PyThreadState* __tstate = wxPyBeginAllowThreads();
21210         result = (wxToolBar *)new wxToolBar();
21211
21212         wxPyEndAllowThreads(__tstate);
21213         if (PyErr_Occurred()) SWIG_fail;
21214     }
21215     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolBar, 1);
21216     return resultobj;
21217     fail:
21218     return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_ToolBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
21223     PyObject *resultobj;
21224     wxToolBar *arg1 = (wxToolBar *) 0 ;
21225     wxWindow *arg2 = (wxWindow *) 0 ;
21226     int arg3 = (int) -1 ;
21227     wxPoint const &arg4_defvalue = wxDefaultPosition ;
21228     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
21229     wxSize const &arg5_defvalue = wxDefaultSize ;
21230     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
21231     long arg6 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
21232     wxString const &arg7_defvalue = wxPyToolBarNameStr ;
21233     wxString *arg7 = (wxString *) &arg7_defvalue ;
21234     bool result;
21235     wxPoint temp4 ;
21236     wxSize temp5 ;
21237     bool temp7 = false ;
21238     PyObject * obj0 = 0 ;
21239     PyObject * obj1 = 0 ;
21240     PyObject * obj2 = 0 ;
21241     PyObject * obj3 = 0 ;
21242     PyObject * obj4 = 0 ;
21243     PyObject * obj5 = 0 ;
21244     PyObject * obj6 = 0 ;
21245     char *kwnames[] = {
21246         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
21247     };
21248
21249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ToolBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21250     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
21251     if (SWIG_arg_fail(1)) SWIG_fail;
21252     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21253     if (SWIG_arg_fail(2)) SWIG_fail;
21254     if (obj2) {
21255         {
21256             arg3 = (int)(SWIG_As_int(obj2));
21257             if (SWIG_arg_fail(3)) SWIG_fail;
21258         }
21259     }
21260     if (obj3) {
21261         {
21262             arg4 = &temp4;
21263             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
21264         }
21265     }
21266     if (obj4) {
21267         {
21268             arg5 = &temp5;
21269             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
21270         }
21271     }
21272     if (obj5) {
21273         {
21274             arg6 = (long)(SWIG_As_long(obj5));
21275             if (SWIG_arg_fail(6)) SWIG_fail;
21276         }
21277     }
21278     if (obj6) {
21279         {
21280             arg7 = wxString_in_helper(obj6);
21281             if (arg7 == NULL) SWIG_fail;
21282             temp7 = true;
21283         }
21284     }
21285     {
21286         PyThreadState* __tstate = wxPyBeginAllowThreads();
21287         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
21288
21289         wxPyEndAllowThreads(__tstate);
21290         if (PyErr_Occurred()) SWIG_fail;
21291     }
21292     {
21293         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21294     }
21295     {
21296         if (temp7)
21297         delete arg7;
21298     }
21299     return resultobj;
21300     fail:
21301     {
21302         if (temp7)
21303         delete arg7;
21304     }
21305     return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_ToolBar_FindToolForPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21310     PyObject *resultobj;
21311     wxToolBar *arg1 = (wxToolBar *) 0 ;
21312     int arg2 ;
21313     int arg3 ;
21314     wxToolBarToolBase *result;
21315     PyObject * obj0 = 0 ;
21316     PyObject * obj1 = 0 ;
21317     PyObject * obj2 = 0 ;
21318     char *kwnames[] = {
21319         (char *) "self",(char *) "x",(char *) "y", NULL
21320     };
21321
21322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBar_FindToolForPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
21323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
21324     if (SWIG_arg_fail(1)) SWIG_fail;
21325     {
21326         arg2 = (int)(SWIG_As_int(obj1));
21327         if (SWIG_arg_fail(2)) SWIG_fail;
21328     }
21329     {
21330         arg3 = (int)(SWIG_As_int(obj2));
21331         if (SWIG_arg_fail(3)) SWIG_fail;
21332     }
21333     {
21334         PyThreadState* __tstate = wxPyBeginAllowThreads();
21335         result = (wxToolBarToolBase *)(arg1)->FindToolForPosition(arg2,arg3);
21336
21337         wxPyEndAllowThreads(__tstate);
21338         if (PyErr_Occurred()) SWIG_fail;
21339     }
21340     {
21341         resultobj = wxPyMake_wxObject(result, 0);
21342     }
21343     return resultobj;
21344     fail:
21345     return NULL;
21346 }
21347
21348
21349 static PyObject *_wrap_ToolBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
21350     PyObject *resultobj;
21351     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
21352     wxVisualAttributes result;
21353     PyObject * obj0 = 0 ;
21354     char *kwnames[] = {
21355         (char *) "variant", NULL
21356     };
21357
21358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToolBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
21359     if (obj0) {
21360         {
21361             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
21362             if (SWIG_arg_fail(1)) SWIG_fail;
21363         }
21364     }
21365     {
21366         if (!wxPyCheckForApp()) SWIG_fail;
21367         PyThreadState* __tstate = wxPyBeginAllowThreads();
21368         result = wxToolBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
21369
21370         wxPyEndAllowThreads(__tstate);
21371         if (PyErr_Occurred()) SWIG_fail;
21372     }
21373     {
21374         wxVisualAttributes * resultptr;
21375         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
21376         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
21377     }
21378     return resultobj;
21379     fail:
21380     return NULL;
21381 }
21382
21383
21384 static PyObject * ToolBar_swigregister(PyObject *, PyObject *args) {
21385     PyObject *obj;
21386     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21387     SWIG_TypeClientData(SWIGTYPE_p_wxToolBar, obj);
21388     Py_INCREF(obj);
21389     return Py_BuildValue((char *)"");
21390 }
21391 static int _wrap_ListCtrlNameStr_set(PyObject *) {
21392     PyErr_SetString(PyExc_TypeError,"Variable ListCtrlNameStr is read-only.");
21393     return 1;
21394 }
21395
21396
21397 static PyObject *_wrap_ListCtrlNameStr_get(void) {
21398     PyObject *pyobj;
21399
21400     {
21401 #if wxUSE_UNICODE
21402         pyobj = PyUnicode_FromWideChar((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
21403 #else
21404         pyobj = PyString_FromStringAndSize((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
21405 #endif
21406     }
21407     return pyobj;
21408 }
21409
21410
21411 static PyObject *_wrap_new_ListItemAttr(PyObject *, PyObject *args, PyObject *kwargs) {
21412     PyObject *resultobj;
21413     wxColour const &arg1_defvalue = wxNullColour ;
21414     wxColour *arg1 = (wxColour *) &arg1_defvalue ;
21415     wxColour const &arg2_defvalue = wxNullColour ;
21416     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
21417     wxFont const &arg3_defvalue = wxNullFont ;
21418     wxFont *arg3 = (wxFont *) &arg3_defvalue ;
21419     wxListItemAttr *result;
21420     wxColour temp1 ;
21421     wxColour temp2 ;
21422     PyObject * obj0 = 0 ;
21423     PyObject * obj1 = 0 ;
21424     PyObject * obj2 = 0 ;
21425     char *kwnames[] = {
21426         (char *) "colText",(char *) "colBack",(char *) "font", NULL
21427     };
21428
21429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ListItemAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
21430     if (obj0) {
21431         {
21432             arg1 = &temp1;
21433             if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
21434         }
21435     }
21436     if (obj1) {
21437         {
21438             arg2 = &temp2;
21439             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21440         }
21441     }
21442     if (obj2) {
21443         {
21444             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
21445             if (SWIG_arg_fail(3)) SWIG_fail;
21446             if (arg3 == NULL) {
21447                 SWIG_null_ref("wxFont");
21448             }
21449             if (SWIG_arg_fail(3)) SWIG_fail;
21450         }
21451     }
21452     {
21453         PyThreadState* __tstate = wxPyBeginAllowThreads();
21454         result = (wxListItemAttr *)new wxListItemAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3);
21455
21456         wxPyEndAllowThreads(__tstate);
21457         if (PyErr_Occurred()) SWIG_fail;
21458     }
21459     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItemAttr, 1);
21460     return resultobj;
21461     fail:
21462     return NULL;
21463 }
21464
21465
21466 static PyObject *_wrap_ListItemAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21467     PyObject *resultobj;
21468     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21469     wxColour *arg2 = 0 ;
21470     wxColour temp2 ;
21471     PyObject * obj0 = 0 ;
21472     PyObject * obj1 = 0 ;
21473     char *kwnames[] = {
21474         (char *) "self",(char *) "colText", NULL
21475     };
21476
21477     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
21478     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21479     if (SWIG_arg_fail(1)) SWIG_fail;
21480     {
21481         arg2 = &temp2;
21482         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21483     }
21484     {
21485         PyThreadState* __tstate = wxPyBeginAllowThreads();
21486         (arg1)->SetTextColour((wxColour const &)*arg2);
21487
21488         wxPyEndAllowThreads(__tstate);
21489         if (PyErr_Occurred()) SWIG_fail;
21490     }
21491     Py_INCREF(Py_None); resultobj = Py_None;
21492     return resultobj;
21493     fail:
21494     return NULL;
21495 }
21496
21497
21498 static PyObject *_wrap_ListItemAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21499     PyObject *resultobj;
21500     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21501     wxColour *arg2 = 0 ;
21502     wxColour temp2 ;
21503     PyObject * obj0 = 0 ;
21504     PyObject * obj1 = 0 ;
21505     char *kwnames[] = {
21506         (char *) "self",(char *) "colBack", NULL
21507     };
21508
21509     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
21510     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21511     if (SWIG_arg_fail(1)) SWIG_fail;
21512     {
21513         arg2 = &temp2;
21514         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21515     }
21516     {
21517         PyThreadState* __tstate = wxPyBeginAllowThreads();
21518         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
21519
21520         wxPyEndAllowThreads(__tstate);
21521         if (PyErr_Occurred()) SWIG_fail;
21522     }
21523     Py_INCREF(Py_None); resultobj = Py_None;
21524     return resultobj;
21525     fail:
21526     return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_ListItemAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
21531     PyObject *resultobj;
21532     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21533     wxFont *arg2 = 0 ;
21534     PyObject * obj0 = 0 ;
21535     PyObject * obj1 = 0 ;
21536     char *kwnames[] = {
21537         (char *) "self",(char *) "font", NULL
21538     };
21539
21540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
21541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21542     if (SWIG_arg_fail(1)) SWIG_fail;
21543     {
21544         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
21545         if (SWIG_arg_fail(2)) SWIG_fail;
21546         if (arg2 == NULL) {
21547             SWIG_null_ref("wxFont");
21548         }
21549         if (SWIG_arg_fail(2)) SWIG_fail;
21550     }
21551     {
21552         PyThreadState* __tstate = wxPyBeginAllowThreads();
21553         (arg1)->SetFont((wxFont const &)*arg2);
21554
21555         wxPyEndAllowThreads(__tstate);
21556         if (PyErr_Occurred()) SWIG_fail;
21557     }
21558     Py_INCREF(Py_None); resultobj = Py_None;
21559     return resultobj;
21560     fail:
21561     return NULL;
21562 }
21563
21564
21565 static PyObject *_wrap_ListItemAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21566     PyObject *resultobj;
21567     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21568     bool result;
21569     PyObject * obj0 = 0 ;
21570     char *kwnames[] = {
21571         (char *) "self", NULL
21572     };
21573
21574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasTextColour",kwnames,&obj0)) goto fail;
21575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21576     if (SWIG_arg_fail(1)) SWIG_fail;
21577     {
21578         PyThreadState* __tstate = wxPyBeginAllowThreads();
21579         result = (bool)(arg1)->HasTextColour();
21580
21581         wxPyEndAllowThreads(__tstate);
21582         if (PyErr_Occurred()) SWIG_fail;
21583     }
21584     {
21585         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21586     }
21587     return resultobj;
21588     fail:
21589     return NULL;
21590 }
21591
21592
21593 static PyObject *_wrap_ListItemAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21594     PyObject *resultobj;
21595     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21596     bool result;
21597     PyObject * obj0 = 0 ;
21598     char *kwnames[] = {
21599         (char *) "self", NULL
21600     };
21601
21602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
21603     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21604     if (SWIG_arg_fail(1)) SWIG_fail;
21605     {
21606         PyThreadState* __tstate = wxPyBeginAllowThreads();
21607         result = (bool)(arg1)->HasBackgroundColour();
21608
21609         wxPyEndAllowThreads(__tstate);
21610         if (PyErr_Occurred()) SWIG_fail;
21611     }
21612     {
21613         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21614     }
21615     return resultobj;
21616     fail:
21617     return NULL;
21618 }
21619
21620
21621 static PyObject *_wrap_ListItemAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
21622     PyObject *resultobj;
21623     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21624     bool result;
21625     PyObject * obj0 = 0 ;
21626     char *kwnames[] = {
21627         (char *) "self", NULL
21628     };
21629
21630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasFont",kwnames,&obj0)) goto fail;
21631     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21632     if (SWIG_arg_fail(1)) SWIG_fail;
21633     {
21634         PyThreadState* __tstate = wxPyBeginAllowThreads();
21635         result = (bool)(arg1)->HasFont();
21636
21637         wxPyEndAllowThreads(__tstate);
21638         if (PyErr_Occurred()) SWIG_fail;
21639     }
21640     {
21641         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21642     }
21643     return resultobj;
21644     fail:
21645     return NULL;
21646 }
21647
21648
21649 static PyObject *_wrap_ListItemAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21650     PyObject *resultobj;
21651     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21652     wxColour result;
21653     PyObject * obj0 = 0 ;
21654     char *kwnames[] = {
21655         (char *) "self", NULL
21656     };
21657
21658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetTextColour",kwnames,&obj0)) goto fail;
21659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21660     if (SWIG_arg_fail(1)) SWIG_fail;
21661     {
21662         PyThreadState* __tstate = wxPyBeginAllowThreads();
21663         result = (arg1)->GetTextColour();
21664
21665         wxPyEndAllowThreads(__tstate);
21666         if (PyErr_Occurred()) SWIG_fail;
21667     }
21668     {
21669         wxColour * resultptr;
21670         resultptr = new wxColour((wxColour &)(result));
21671         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21672     }
21673     return resultobj;
21674     fail:
21675     return NULL;
21676 }
21677
21678
21679 static PyObject *_wrap_ListItemAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21680     PyObject *resultobj;
21681     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21682     wxColour result;
21683     PyObject * obj0 = 0 ;
21684     char *kwnames[] = {
21685         (char *) "self", NULL
21686     };
21687
21688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
21689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21690     if (SWIG_arg_fail(1)) SWIG_fail;
21691     {
21692         PyThreadState* __tstate = wxPyBeginAllowThreads();
21693         result = (arg1)->GetBackgroundColour();
21694
21695         wxPyEndAllowThreads(__tstate);
21696         if (PyErr_Occurred()) SWIG_fail;
21697     }
21698     {
21699         wxColour * resultptr;
21700         resultptr = new wxColour((wxColour &)(result));
21701         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21702     }
21703     return resultobj;
21704     fail:
21705     return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_ListItemAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
21710     PyObject *resultobj;
21711     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21712     wxFont result;
21713     PyObject * obj0 = 0 ;
21714     char *kwnames[] = {
21715         (char *) "self", NULL
21716     };
21717
21718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetFont",kwnames,&obj0)) goto fail;
21719     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21720     if (SWIG_arg_fail(1)) SWIG_fail;
21721     {
21722         PyThreadState* __tstate = wxPyBeginAllowThreads();
21723         result = (arg1)->GetFont();
21724
21725         wxPyEndAllowThreads(__tstate);
21726         if (PyErr_Occurred()) SWIG_fail;
21727     }
21728     {
21729         wxFont * resultptr;
21730         resultptr = new wxFont((wxFont &)(result));
21731         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
21732     }
21733     return resultobj;
21734     fail:
21735     return NULL;
21736 }
21737
21738
21739 static PyObject *_wrap_ListItemAttr_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
21740     PyObject *resultobj;
21741     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21742     PyObject * obj0 = 0 ;
21743     char *kwnames[] = {
21744         (char *) "self", NULL
21745     };
21746
21747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_Destroy",kwnames,&obj0)) goto fail;
21748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21749     if (SWIG_arg_fail(1)) SWIG_fail;
21750     {
21751         PyThreadState* __tstate = wxPyBeginAllowThreads();
21752         wxListItemAttr_Destroy(arg1);
21753
21754         wxPyEndAllowThreads(__tstate);
21755         if (PyErr_Occurred()) SWIG_fail;
21756     }
21757     Py_INCREF(Py_None); resultobj = Py_None;
21758     return resultobj;
21759     fail:
21760     return NULL;
21761 }
21762
21763
21764 static PyObject * ListItemAttr_swigregister(PyObject *, PyObject *args) {
21765     PyObject *obj;
21766     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21767     SWIG_TypeClientData(SWIGTYPE_p_wxListItemAttr, obj);
21768     Py_INCREF(obj);
21769     return Py_BuildValue((char *)"");
21770 }
21771 static PyObject *_wrap_new_ListItem(PyObject *, PyObject *args, PyObject *kwargs) {
21772     PyObject *resultobj;
21773     wxListItem *result;
21774     char *kwnames[] = {
21775         NULL
21776     };
21777
21778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ListItem",kwnames)) goto fail;
21779     {
21780         PyThreadState* __tstate = wxPyBeginAllowThreads();
21781         result = (wxListItem *)new wxListItem();
21782
21783         wxPyEndAllowThreads(__tstate);
21784         if (PyErr_Occurred()) SWIG_fail;
21785     }
21786     {
21787         resultobj = wxPyMake_wxObject(result, 1);
21788     }
21789     return resultobj;
21790     fail:
21791     return NULL;
21792 }
21793
21794
21795 static PyObject *_wrap_delete_ListItem(PyObject *, PyObject *args, PyObject *kwargs) {
21796     PyObject *resultobj;
21797     wxListItem *arg1 = (wxListItem *) 0 ;
21798     PyObject * obj0 = 0 ;
21799     char *kwnames[] = {
21800         (char *) "self", NULL
21801     };
21802
21803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ListItem",kwnames,&obj0)) goto fail;
21804     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21805     if (SWIG_arg_fail(1)) SWIG_fail;
21806     {
21807         PyThreadState* __tstate = wxPyBeginAllowThreads();
21808         delete arg1;
21809
21810         wxPyEndAllowThreads(__tstate);
21811         if (PyErr_Occurred()) SWIG_fail;
21812     }
21813     Py_INCREF(Py_None); resultobj = Py_None;
21814     return resultobj;
21815     fail:
21816     return NULL;
21817 }
21818
21819
21820 static PyObject *_wrap_ListItem_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
21821     PyObject *resultobj;
21822     wxListItem *arg1 = (wxListItem *) 0 ;
21823     PyObject * obj0 = 0 ;
21824     char *kwnames[] = {
21825         (char *) "self", NULL
21826     };
21827
21828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_Clear",kwnames,&obj0)) goto fail;
21829     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21830     if (SWIG_arg_fail(1)) SWIG_fail;
21831     {
21832         PyThreadState* __tstate = wxPyBeginAllowThreads();
21833         (arg1)->Clear();
21834
21835         wxPyEndAllowThreads(__tstate);
21836         if (PyErr_Occurred()) SWIG_fail;
21837     }
21838     Py_INCREF(Py_None); resultobj = Py_None;
21839     return resultobj;
21840     fail:
21841     return NULL;
21842 }
21843
21844
21845 static PyObject *_wrap_ListItem_ClearAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
21846     PyObject *resultobj;
21847     wxListItem *arg1 = (wxListItem *) 0 ;
21848     PyObject * obj0 = 0 ;
21849     char *kwnames[] = {
21850         (char *) "self", NULL
21851     };
21852
21853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_ClearAttributes",kwnames,&obj0)) goto fail;
21854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21855     if (SWIG_arg_fail(1)) SWIG_fail;
21856     {
21857         PyThreadState* __tstate = wxPyBeginAllowThreads();
21858         (arg1)->ClearAttributes();
21859
21860         wxPyEndAllowThreads(__tstate);
21861         if (PyErr_Occurred()) SWIG_fail;
21862     }
21863     Py_INCREF(Py_None); resultobj = Py_None;
21864     return resultobj;
21865     fail:
21866     return NULL;
21867 }
21868
21869
21870 static PyObject *_wrap_ListItem_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
21871     PyObject *resultobj;
21872     wxListItem *arg1 = (wxListItem *) 0 ;
21873     long arg2 ;
21874     PyObject * obj0 = 0 ;
21875     PyObject * obj1 = 0 ;
21876     char *kwnames[] = {
21877         (char *) "self",(char *) "mask", NULL
21878     };
21879
21880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetMask",kwnames,&obj0,&obj1)) goto fail;
21881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21882     if (SWIG_arg_fail(1)) SWIG_fail;
21883     {
21884         arg2 = (long)(SWIG_As_long(obj1));
21885         if (SWIG_arg_fail(2)) SWIG_fail;
21886     }
21887     {
21888         PyThreadState* __tstate = wxPyBeginAllowThreads();
21889         (arg1)->SetMask(arg2);
21890
21891         wxPyEndAllowThreads(__tstate);
21892         if (PyErr_Occurred()) SWIG_fail;
21893     }
21894     Py_INCREF(Py_None); resultobj = Py_None;
21895     return resultobj;
21896     fail:
21897     return NULL;
21898 }
21899
21900
21901 static PyObject *_wrap_ListItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
21902     PyObject *resultobj;
21903     wxListItem *arg1 = (wxListItem *) 0 ;
21904     long arg2 ;
21905     PyObject * obj0 = 0 ;
21906     PyObject * obj1 = 0 ;
21907     char *kwnames[] = {
21908         (char *) "self",(char *) "id", NULL
21909     };
21910
21911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetId",kwnames,&obj0,&obj1)) goto fail;
21912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21913     if (SWIG_arg_fail(1)) SWIG_fail;
21914     {
21915         arg2 = (long)(SWIG_As_long(obj1));
21916         if (SWIG_arg_fail(2)) SWIG_fail;
21917     }
21918     {
21919         PyThreadState* __tstate = wxPyBeginAllowThreads();
21920         (arg1)->SetId(arg2);
21921
21922         wxPyEndAllowThreads(__tstate);
21923         if (PyErr_Occurred()) SWIG_fail;
21924     }
21925     Py_INCREF(Py_None); resultobj = Py_None;
21926     return resultobj;
21927     fail:
21928     return NULL;
21929 }
21930
21931
21932 static PyObject *_wrap_ListItem_SetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
21933     PyObject *resultobj;
21934     wxListItem *arg1 = (wxListItem *) 0 ;
21935     int arg2 ;
21936     PyObject * obj0 = 0 ;
21937     PyObject * obj1 = 0 ;
21938     char *kwnames[] = {
21939         (char *) "self",(char *) "col", NULL
21940     };
21941
21942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetColumn",kwnames,&obj0,&obj1)) goto fail;
21943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21944     if (SWIG_arg_fail(1)) SWIG_fail;
21945     {
21946         arg2 = (int)(SWIG_As_int(obj1));
21947         if (SWIG_arg_fail(2)) SWIG_fail;
21948     }
21949     {
21950         PyThreadState* __tstate = wxPyBeginAllowThreads();
21951         (arg1)->SetColumn(arg2);
21952
21953         wxPyEndAllowThreads(__tstate);
21954         if (PyErr_Occurred()) SWIG_fail;
21955     }
21956     Py_INCREF(Py_None); resultobj = Py_None;
21957     return resultobj;
21958     fail:
21959     return NULL;
21960 }
21961
21962
21963 static PyObject *_wrap_ListItem_SetState(PyObject *, PyObject *args, PyObject *kwargs) {
21964     PyObject *resultobj;
21965     wxListItem *arg1 = (wxListItem *) 0 ;
21966     long arg2 ;
21967     PyObject * obj0 = 0 ;
21968     PyObject * obj1 = 0 ;
21969     char *kwnames[] = {
21970         (char *) "self",(char *) "state", NULL
21971     };
21972
21973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetState",kwnames,&obj0,&obj1)) goto fail;
21974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21975     if (SWIG_arg_fail(1)) SWIG_fail;
21976     {
21977         arg2 = (long)(SWIG_As_long(obj1));
21978         if (SWIG_arg_fail(2)) SWIG_fail;
21979     }
21980     {
21981         PyThreadState* __tstate = wxPyBeginAllowThreads();
21982         (arg1)->SetState(arg2);
21983
21984         wxPyEndAllowThreads(__tstate);
21985         if (PyErr_Occurred()) SWIG_fail;
21986     }
21987     Py_INCREF(Py_None); resultobj = Py_None;
21988     return resultobj;
21989     fail:
21990     return NULL;
21991 }
21992
21993
21994 static PyObject *_wrap_ListItem_SetStateMask(PyObject *, PyObject *args, PyObject *kwargs) {
21995     PyObject *resultobj;
21996     wxListItem *arg1 = (wxListItem *) 0 ;
21997     long arg2 ;
21998     PyObject * obj0 = 0 ;
21999     PyObject * obj1 = 0 ;
22000     char *kwnames[] = {
22001         (char *) "self",(char *) "stateMask", NULL
22002     };
22003
22004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetStateMask",kwnames,&obj0,&obj1)) goto fail;
22005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22006     if (SWIG_arg_fail(1)) SWIG_fail;
22007     {
22008         arg2 = (long)(SWIG_As_long(obj1));
22009         if (SWIG_arg_fail(2)) SWIG_fail;
22010     }
22011     {
22012         PyThreadState* __tstate = wxPyBeginAllowThreads();
22013         (arg1)->SetStateMask(arg2);
22014
22015         wxPyEndAllowThreads(__tstate);
22016         if (PyErr_Occurred()) SWIG_fail;
22017     }
22018     Py_INCREF(Py_None); resultobj = Py_None;
22019     return resultobj;
22020     fail:
22021     return NULL;
22022 }
22023
22024
22025 static PyObject *_wrap_ListItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
22026     PyObject *resultobj;
22027     wxListItem *arg1 = (wxListItem *) 0 ;
22028     wxString *arg2 = 0 ;
22029     bool temp2 = false ;
22030     PyObject * obj0 = 0 ;
22031     PyObject * obj1 = 0 ;
22032     char *kwnames[] = {
22033         (char *) "self",(char *) "text", NULL
22034     };
22035
22036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetText",kwnames,&obj0,&obj1)) goto fail;
22037     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22038     if (SWIG_arg_fail(1)) SWIG_fail;
22039     {
22040         arg2 = wxString_in_helper(obj1);
22041         if (arg2 == NULL) SWIG_fail;
22042         temp2 = true;
22043     }
22044     {
22045         PyThreadState* __tstate = wxPyBeginAllowThreads();
22046         (arg1)->SetText((wxString const &)*arg2);
22047
22048         wxPyEndAllowThreads(__tstate);
22049         if (PyErr_Occurred()) SWIG_fail;
22050     }
22051     Py_INCREF(Py_None); resultobj = Py_None;
22052     {
22053         if (temp2)
22054         delete arg2;
22055     }
22056     return resultobj;
22057     fail:
22058     {
22059         if (temp2)
22060         delete arg2;
22061     }
22062     return NULL;
22063 }
22064
22065
22066 static PyObject *_wrap_ListItem_SetImage(PyObject *, PyObject *args, PyObject *kwargs) {
22067     PyObject *resultobj;
22068     wxListItem *arg1 = (wxListItem *) 0 ;
22069     int arg2 ;
22070     PyObject * obj0 = 0 ;
22071     PyObject * obj1 = 0 ;
22072     char *kwnames[] = {
22073         (char *) "self",(char *) "image", NULL
22074     };
22075
22076     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetImage",kwnames,&obj0,&obj1)) goto fail;
22077     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22078     if (SWIG_arg_fail(1)) SWIG_fail;
22079     {
22080         arg2 = (int)(SWIG_As_int(obj1));
22081         if (SWIG_arg_fail(2)) SWIG_fail;
22082     }
22083     {
22084         PyThreadState* __tstate = wxPyBeginAllowThreads();
22085         (arg1)->SetImage(arg2);
22086
22087         wxPyEndAllowThreads(__tstate);
22088         if (PyErr_Occurred()) SWIG_fail;
22089     }
22090     Py_INCREF(Py_None); resultobj = Py_None;
22091     return resultobj;
22092     fail:
22093     return NULL;
22094 }
22095
22096
22097 static PyObject *_wrap_ListItem_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
22098     PyObject *resultobj;
22099     wxListItem *arg1 = (wxListItem *) 0 ;
22100     long arg2 ;
22101     PyObject * obj0 = 0 ;
22102     PyObject * obj1 = 0 ;
22103     char *kwnames[] = {
22104         (char *) "self",(char *) "data", NULL
22105     };
22106
22107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetData",kwnames,&obj0,&obj1)) goto fail;
22108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22109     if (SWIG_arg_fail(1)) SWIG_fail;
22110     {
22111         arg2 = (long)(SWIG_As_long(obj1));
22112         if (SWIG_arg_fail(2)) SWIG_fail;
22113     }
22114     {
22115         PyThreadState* __tstate = wxPyBeginAllowThreads();
22116         (arg1)->SetData(arg2);
22117
22118         wxPyEndAllowThreads(__tstate);
22119         if (PyErr_Occurred()) SWIG_fail;
22120     }
22121     Py_INCREF(Py_None); resultobj = Py_None;
22122     return resultobj;
22123     fail:
22124     return NULL;
22125 }
22126
22127
22128 static PyObject *_wrap_ListItem_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
22129     PyObject *resultobj;
22130     wxListItem *arg1 = (wxListItem *) 0 ;
22131     int arg2 ;
22132     PyObject * obj0 = 0 ;
22133     PyObject * obj1 = 0 ;
22134     char *kwnames[] = {
22135         (char *) "self",(char *) "width", NULL
22136     };
22137
22138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetWidth",kwnames,&obj0,&obj1)) goto fail;
22139     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22140     if (SWIG_arg_fail(1)) SWIG_fail;
22141     {
22142         arg2 = (int)(SWIG_As_int(obj1));
22143         if (SWIG_arg_fail(2)) SWIG_fail;
22144     }
22145     {
22146         PyThreadState* __tstate = wxPyBeginAllowThreads();
22147         (arg1)->SetWidth(arg2);
22148
22149         wxPyEndAllowThreads(__tstate);
22150         if (PyErr_Occurred()) SWIG_fail;
22151     }
22152     Py_INCREF(Py_None); resultobj = Py_None;
22153     return resultobj;
22154     fail:
22155     return NULL;
22156 }
22157
22158
22159 static PyObject *_wrap_ListItem_SetAlign(PyObject *, PyObject *args, PyObject *kwargs) {
22160     PyObject *resultobj;
22161     wxListItem *arg1 = (wxListItem *) 0 ;
22162     wxListColumnFormat arg2 ;
22163     PyObject * obj0 = 0 ;
22164     PyObject * obj1 = 0 ;
22165     char *kwnames[] = {
22166         (char *) "self",(char *) "align", NULL
22167     };
22168
22169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetAlign",kwnames,&obj0,&obj1)) goto fail;
22170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22171     if (SWIG_arg_fail(1)) SWIG_fail;
22172     {
22173         arg2 = (wxListColumnFormat)(SWIG_As_int(obj1));
22174         if (SWIG_arg_fail(2)) SWIG_fail;
22175     }
22176     {
22177         PyThreadState* __tstate = wxPyBeginAllowThreads();
22178         (arg1)->SetAlign((wxListColumnFormat )arg2);
22179
22180         wxPyEndAllowThreads(__tstate);
22181         if (PyErr_Occurred()) SWIG_fail;
22182     }
22183     Py_INCREF(Py_None); resultobj = Py_None;
22184     return resultobj;
22185     fail:
22186     return NULL;
22187 }
22188
22189
22190 static PyObject *_wrap_ListItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
22191     PyObject *resultobj;
22192     wxListItem *arg1 = (wxListItem *) 0 ;
22193     wxColour *arg2 = 0 ;
22194     wxColour temp2 ;
22195     PyObject * obj0 = 0 ;
22196     PyObject * obj1 = 0 ;
22197     char *kwnames[] = {
22198         (char *) "self",(char *) "colText", NULL
22199     };
22200
22201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
22202     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22203     if (SWIG_arg_fail(1)) SWIG_fail;
22204     {
22205         arg2 = &temp2;
22206         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22207     }
22208     {
22209         PyThreadState* __tstate = wxPyBeginAllowThreads();
22210         (arg1)->SetTextColour((wxColour const &)*arg2);
22211
22212         wxPyEndAllowThreads(__tstate);
22213         if (PyErr_Occurred()) SWIG_fail;
22214     }
22215     Py_INCREF(Py_None); resultobj = Py_None;
22216     return resultobj;
22217     fail:
22218     return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_ListItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
22223     PyObject *resultobj;
22224     wxListItem *arg1 = (wxListItem *) 0 ;
22225     wxColour *arg2 = 0 ;
22226     wxColour temp2 ;
22227     PyObject * obj0 = 0 ;
22228     PyObject * obj1 = 0 ;
22229     char *kwnames[] = {
22230         (char *) "self",(char *) "colBack", NULL
22231     };
22232
22233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
22234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22235     if (SWIG_arg_fail(1)) SWIG_fail;
22236     {
22237         arg2 = &temp2;
22238         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22239     }
22240     {
22241         PyThreadState* __tstate = wxPyBeginAllowThreads();
22242         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
22243
22244         wxPyEndAllowThreads(__tstate);
22245         if (PyErr_Occurred()) SWIG_fail;
22246     }
22247     Py_INCREF(Py_None); resultobj = Py_None;
22248     return resultobj;
22249     fail:
22250     return NULL;
22251 }
22252
22253
22254 static PyObject *_wrap_ListItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
22255     PyObject *resultobj;
22256     wxListItem *arg1 = (wxListItem *) 0 ;
22257     wxFont *arg2 = 0 ;
22258     PyObject * obj0 = 0 ;
22259     PyObject * obj1 = 0 ;
22260     char *kwnames[] = {
22261         (char *) "self",(char *) "font", NULL
22262     };
22263
22264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
22265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22266     if (SWIG_arg_fail(1)) SWIG_fail;
22267     {
22268         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
22269         if (SWIG_arg_fail(2)) SWIG_fail;
22270         if (arg2 == NULL) {
22271             SWIG_null_ref("wxFont");
22272         }
22273         if (SWIG_arg_fail(2)) SWIG_fail;
22274     }
22275     {
22276         PyThreadState* __tstate = wxPyBeginAllowThreads();
22277         (arg1)->SetFont((wxFont const &)*arg2);
22278
22279         wxPyEndAllowThreads(__tstate);
22280         if (PyErr_Occurred()) SWIG_fail;
22281     }
22282     Py_INCREF(Py_None); resultobj = Py_None;
22283     return resultobj;
22284     fail:
22285     return NULL;
22286 }
22287
22288
22289 static PyObject *_wrap_ListItem_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
22290     PyObject *resultobj;
22291     wxListItem *arg1 = (wxListItem *) 0 ;
22292     long result;
22293     PyObject * obj0 = 0 ;
22294     char *kwnames[] = {
22295         (char *) "self", NULL
22296     };
22297
22298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetMask",kwnames,&obj0)) goto fail;
22299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22300     if (SWIG_arg_fail(1)) SWIG_fail;
22301     {
22302         PyThreadState* __tstate = wxPyBeginAllowThreads();
22303         result = (long)(arg1)->GetMask();
22304
22305         wxPyEndAllowThreads(__tstate);
22306         if (PyErr_Occurred()) SWIG_fail;
22307     }
22308     {
22309         resultobj = SWIG_From_long((long)(result));
22310     }
22311     return resultobj;
22312     fail:
22313     return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_ListItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
22318     PyObject *resultobj;
22319     wxListItem *arg1 = (wxListItem *) 0 ;
22320     long result;
22321     PyObject * obj0 = 0 ;
22322     char *kwnames[] = {
22323         (char *) "self", NULL
22324     };
22325
22326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetId",kwnames,&obj0)) goto fail;
22327     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22328     if (SWIG_arg_fail(1)) SWIG_fail;
22329     {
22330         PyThreadState* __tstate = wxPyBeginAllowThreads();
22331         result = (long)(arg1)->GetId();
22332
22333         wxPyEndAllowThreads(__tstate);
22334         if (PyErr_Occurred()) SWIG_fail;
22335     }
22336     {
22337         resultobj = SWIG_From_long((long)(result));
22338     }
22339     return resultobj;
22340     fail:
22341     return NULL;
22342 }
22343
22344
22345 static PyObject *_wrap_ListItem_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
22346     PyObject *resultobj;
22347     wxListItem *arg1 = (wxListItem *) 0 ;
22348     int result;
22349     PyObject * obj0 = 0 ;
22350     char *kwnames[] = {
22351         (char *) "self", NULL
22352     };
22353
22354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetColumn",kwnames,&obj0)) goto fail;
22355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22356     if (SWIG_arg_fail(1)) SWIG_fail;
22357     {
22358         PyThreadState* __tstate = wxPyBeginAllowThreads();
22359         result = (int)(arg1)->GetColumn();
22360
22361         wxPyEndAllowThreads(__tstate);
22362         if (PyErr_Occurred()) SWIG_fail;
22363     }
22364     {
22365         resultobj = SWIG_From_int((int)(result));
22366     }
22367     return resultobj;
22368     fail:
22369     return NULL;
22370 }
22371
22372
22373 static PyObject *_wrap_ListItem_GetState(PyObject *, PyObject *args, PyObject *kwargs) {
22374     PyObject *resultobj;
22375     wxListItem *arg1 = (wxListItem *) 0 ;
22376     long result;
22377     PyObject * obj0 = 0 ;
22378     char *kwnames[] = {
22379         (char *) "self", NULL
22380     };
22381
22382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetState",kwnames,&obj0)) goto fail;
22383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22384     if (SWIG_arg_fail(1)) SWIG_fail;
22385     {
22386         PyThreadState* __tstate = wxPyBeginAllowThreads();
22387         result = (long)(arg1)->GetState();
22388
22389         wxPyEndAllowThreads(__tstate);
22390         if (PyErr_Occurred()) SWIG_fail;
22391     }
22392     {
22393         resultobj = SWIG_From_long((long)(result));
22394     }
22395     return resultobj;
22396     fail:
22397     return NULL;
22398 }
22399
22400
22401 static PyObject *_wrap_ListItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
22402     PyObject *resultobj;
22403     wxListItem *arg1 = (wxListItem *) 0 ;
22404     wxString *result;
22405     PyObject * obj0 = 0 ;
22406     char *kwnames[] = {
22407         (char *) "self", NULL
22408     };
22409
22410     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetText",kwnames,&obj0)) goto fail;
22411     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22412     if (SWIG_arg_fail(1)) SWIG_fail;
22413     {
22414         PyThreadState* __tstate = wxPyBeginAllowThreads();
22415         {
22416             wxString const &_result_ref = (arg1)->GetText();
22417             result = (wxString *) &_result_ref;
22418         }
22419
22420         wxPyEndAllowThreads(__tstate);
22421         if (PyErr_Occurred()) SWIG_fail;
22422     }
22423     {
22424 #if wxUSE_UNICODE
22425         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22426 #else
22427         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22428 #endif
22429     }
22430     return resultobj;
22431     fail:
22432     return NULL;
22433 }
22434
22435
22436 static PyObject *_wrap_ListItem_GetImage(PyObject *, PyObject *args, PyObject *kwargs) {
22437     PyObject *resultobj;
22438     wxListItem *arg1 = (wxListItem *) 0 ;
22439     int result;
22440     PyObject * obj0 = 0 ;
22441     char *kwnames[] = {
22442         (char *) "self", NULL
22443     };
22444
22445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetImage",kwnames,&obj0)) goto fail;
22446     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22447     if (SWIG_arg_fail(1)) SWIG_fail;
22448     {
22449         PyThreadState* __tstate = wxPyBeginAllowThreads();
22450         result = (int)(arg1)->GetImage();
22451
22452         wxPyEndAllowThreads(__tstate);
22453         if (PyErr_Occurred()) SWIG_fail;
22454     }
22455     {
22456         resultobj = SWIG_From_int((int)(result));
22457     }
22458     return resultobj;
22459     fail:
22460     return NULL;
22461 }
22462
22463
22464 static PyObject *_wrap_ListItem_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
22465     PyObject *resultobj;
22466     wxListItem *arg1 = (wxListItem *) 0 ;
22467     long result;
22468     PyObject * obj0 = 0 ;
22469     char *kwnames[] = {
22470         (char *) "self", NULL
22471     };
22472
22473     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetData",kwnames,&obj0)) goto fail;
22474     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22475     if (SWIG_arg_fail(1)) SWIG_fail;
22476     {
22477         PyThreadState* __tstate = wxPyBeginAllowThreads();
22478         result = (long)(arg1)->GetData();
22479
22480         wxPyEndAllowThreads(__tstate);
22481         if (PyErr_Occurred()) SWIG_fail;
22482     }
22483     {
22484         resultobj = SWIG_From_long((long)(result));
22485     }
22486     return resultobj;
22487     fail:
22488     return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_ListItem_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
22493     PyObject *resultobj;
22494     wxListItem *arg1 = (wxListItem *) 0 ;
22495     int result;
22496     PyObject * obj0 = 0 ;
22497     char *kwnames[] = {
22498         (char *) "self", NULL
22499     };
22500
22501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetWidth",kwnames,&obj0)) goto fail;
22502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22503     if (SWIG_arg_fail(1)) SWIG_fail;
22504     {
22505         PyThreadState* __tstate = wxPyBeginAllowThreads();
22506         result = (int)(arg1)->GetWidth();
22507
22508         wxPyEndAllowThreads(__tstate);
22509         if (PyErr_Occurred()) SWIG_fail;
22510     }
22511     {
22512         resultobj = SWIG_From_int((int)(result));
22513     }
22514     return resultobj;
22515     fail:
22516     return NULL;
22517 }
22518
22519
22520 static PyObject *_wrap_ListItem_GetAlign(PyObject *, PyObject *args, PyObject *kwargs) {
22521     PyObject *resultobj;
22522     wxListItem *arg1 = (wxListItem *) 0 ;
22523     wxListColumnFormat result;
22524     PyObject * obj0 = 0 ;
22525     char *kwnames[] = {
22526         (char *) "self", NULL
22527     };
22528
22529     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetAlign",kwnames,&obj0)) goto fail;
22530     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22531     if (SWIG_arg_fail(1)) SWIG_fail;
22532     {
22533         PyThreadState* __tstate = wxPyBeginAllowThreads();
22534         result = (wxListColumnFormat)(arg1)->GetAlign();
22535
22536         wxPyEndAllowThreads(__tstate);
22537         if (PyErr_Occurred()) SWIG_fail;
22538     }
22539     resultobj = SWIG_From_int((result));
22540     return resultobj;
22541     fail:
22542     return NULL;
22543 }
22544
22545
22546 static PyObject *_wrap_ListItem_GetAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
22547     PyObject *resultobj;
22548     wxListItem *arg1 = (wxListItem *) 0 ;
22549     wxListItemAttr *result;
22550     PyObject * obj0 = 0 ;
22551     char *kwnames[] = {
22552         (char *) "self", NULL
22553     };
22554
22555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetAttributes",kwnames,&obj0)) goto fail;
22556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22557     if (SWIG_arg_fail(1)) SWIG_fail;
22558     {
22559         PyThreadState* __tstate = wxPyBeginAllowThreads();
22560         result = (wxListItemAttr *)(arg1)->GetAttributes();
22561
22562         wxPyEndAllowThreads(__tstate);
22563         if (PyErr_Occurred()) SWIG_fail;
22564     }
22565     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItemAttr, 0);
22566     return resultobj;
22567     fail:
22568     return NULL;
22569 }
22570
22571
22572 static PyObject *_wrap_ListItem_HasAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
22573     PyObject *resultobj;
22574     wxListItem *arg1 = (wxListItem *) 0 ;
22575     bool result;
22576     PyObject * obj0 = 0 ;
22577     char *kwnames[] = {
22578         (char *) "self", NULL
22579     };
22580
22581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_HasAttributes",kwnames,&obj0)) goto fail;
22582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22583     if (SWIG_arg_fail(1)) SWIG_fail;
22584     {
22585         PyThreadState* __tstate = wxPyBeginAllowThreads();
22586         result = (bool)(arg1)->HasAttributes();
22587
22588         wxPyEndAllowThreads(__tstate);
22589         if (PyErr_Occurred()) SWIG_fail;
22590     }
22591     {
22592         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22593     }
22594     return resultobj;
22595     fail:
22596     return NULL;
22597 }
22598
22599
22600 static PyObject *_wrap_ListItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
22601     PyObject *resultobj;
22602     wxListItem *arg1 = (wxListItem *) 0 ;
22603     wxColour result;
22604     PyObject * obj0 = 0 ;
22605     char *kwnames[] = {
22606         (char *) "self", NULL
22607     };
22608
22609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetTextColour",kwnames,&obj0)) goto fail;
22610     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22611     if (SWIG_arg_fail(1)) SWIG_fail;
22612     {
22613         PyThreadState* __tstate = wxPyBeginAllowThreads();
22614         result = ((wxListItem const *)arg1)->GetTextColour();
22615
22616         wxPyEndAllowThreads(__tstate);
22617         if (PyErr_Occurred()) SWIG_fail;
22618     }
22619     {
22620         wxColour * resultptr;
22621         resultptr = new wxColour((wxColour &)(result));
22622         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
22623     }
22624     return resultobj;
22625     fail:
22626     return NULL;
22627 }
22628
22629
22630 static PyObject *_wrap_ListItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
22631     PyObject *resultobj;
22632     wxListItem *arg1 = (wxListItem *) 0 ;
22633     wxColour result;
22634     PyObject * obj0 = 0 ;
22635     char *kwnames[] = {
22636         (char *) "self", NULL
22637     };
22638
22639     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
22640     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22641     if (SWIG_arg_fail(1)) SWIG_fail;
22642     {
22643         PyThreadState* __tstate = wxPyBeginAllowThreads();
22644         result = ((wxListItem const *)arg1)->GetBackgroundColour();
22645
22646         wxPyEndAllowThreads(__tstate);
22647         if (PyErr_Occurred()) SWIG_fail;
22648     }
22649     {
22650         wxColour * resultptr;
22651         resultptr = new wxColour((wxColour &)(result));
22652         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
22653     }
22654     return resultobj;
22655     fail:
22656     return NULL;
22657 }
22658
22659
22660 static PyObject *_wrap_ListItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
22661     PyObject *resultobj;
22662     wxListItem *arg1 = (wxListItem *) 0 ;
22663     wxFont result;
22664     PyObject * obj0 = 0 ;
22665     char *kwnames[] = {
22666         (char *) "self", NULL
22667     };
22668
22669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetFont",kwnames,&obj0)) goto fail;
22670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22671     if (SWIG_arg_fail(1)) SWIG_fail;
22672     {
22673         PyThreadState* __tstate = wxPyBeginAllowThreads();
22674         result = ((wxListItem const *)arg1)->GetFont();
22675
22676         wxPyEndAllowThreads(__tstate);
22677         if (PyErr_Occurred()) SWIG_fail;
22678     }
22679     {
22680         wxFont * resultptr;
22681         resultptr = new wxFont((wxFont &)(result));
22682         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
22683     }
22684     return resultobj;
22685     fail:
22686     return NULL;
22687 }
22688
22689
22690 static PyObject *_wrap_ListItem_m_mask_set(PyObject *, PyObject *args, PyObject *kwargs) {
22691     PyObject *resultobj;
22692     wxListItem *arg1 = (wxListItem *) 0 ;
22693     long arg2 ;
22694     PyObject * obj0 = 0 ;
22695     PyObject * obj1 = 0 ;
22696     char *kwnames[] = {
22697         (char *) "self",(char *) "m_mask", NULL
22698     };
22699
22700     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_mask_set",kwnames,&obj0,&obj1)) goto fail;
22701     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22702     if (SWIG_arg_fail(1)) SWIG_fail;
22703     {
22704         arg2 = (long)(SWIG_As_long(obj1));
22705         if (SWIG_arg_fail(2)) SWIG_fail;
22706     }
22707     if (arg1) (arg1)->m_mask = arg2;
22708
22709     Py_INCREF(Py_None); resultobj = Py_None;
22710     return resultobj;
22711     fail:
22712     return NULL;
22713 }
22714
22715
22716 static PyObject *_wrap_ListItem_m_mask_get(PyObject *, PyObject *args, PyObject *kwargs) {
22717     PyObject *resultobj;
22718     wxListItem *arg1 = (wxListItem *) 0 ;
22719     long result;
22720     PyObject * obj0 = 0 ;
22721     char *kwnames[] = {
22722         (char *) "self", NULL
22723     };
22724
22725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_mask_get",kwnames,&obj0)) goto fail;
22726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22727     if (SWIG_arg_fail(1)) SWIG_fail;
22728     result = (long) ((arg1)->m_mask);
22729
22730     {
22731         resultobj = SWIG_From_long((long)(result));
22732     }
22733     return resultobj;
22734     fail:
22735     return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_ListItem_m_itemId_set(PyObject *, PyObject *args, PyObject *kwargs) {
22740     PyObject *resultobj;
22741     wxListItem *arg1 = (wxListItem *) 0 ;
22742     long arg2 ;
22743     PyObject * obj0 = 0 ;
22744     PyObject * obj1 = 0 ;
22745     char *kwnames[] = {
22746         (char *) "self",(char *) "m_itemId", NULL
22747     };
22748
22749     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_itemId_set",kwnames,&obj0,&obj1)) goto fail;
22750     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22751     if (SWIG_arg_fail(1)) SWIG_fail;
22752     {
22753         arg2 = (long)(SWIG_As_long(obj1));
22754         if (SWIG_arg_fail(2)) SWIG_fail;
22755     }
22756     if (arg1) (arg1)->m_itemId = arg2;
22757
22758     Py_INCREF(Py_None); resultobj = Py_None;
22759     return resultobj;
22760     fail:
22761     return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_ListItem_m_itemId_get(PyObject *, PyObject *args, PyObject *kwargs) {
22766     PyObject *resultobj;
22767     wxListItem *arg1 = (wxListItem *) 0 ;
22768     long result;
22769     PyObject * obj0 = 0 ;
22770     char *kwnames[] = {
22771         (char *) "self", NULL
22772     };
22773
22774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_itemId_get",kwnames,&obj0)) goto fail;
22775     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22776     if (SWIG_arg_fail(1)) SWIG_fail;
22777     result = (long) ((arg1)->m_itemId);
22778
22779     {
22780         resultobj = SWIG_From_long((long)(result));
22781     }
22782     return resultobj;
22783     fail:
22784     return NULL;
22785 }
22786
22787
22788 static PyObject *_wrap_ListItem_m_col_set(PyObject *, PyObject *args, PyObject *kwargs) {
22789     PyObject *resultobj;
22790     wxListItem *arg1 = (wxListItem *) 0 ;
22791     int arg2 ;
22792     PyObject * obj0 = 0 ;
22793     PyObject * obj1 = 0 ;
22794     char *kwnames[] = {
22795         (char *) "self",(char *) "m_col", NULL
22796     };
22797
22798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_col_set",kwnames,&obj0,&obj1)) goto fail;
22799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22800     if (SWIG_arg_fail(1)) SWIG_fail;
22801     {
22802         arg2 = (int)(SWIG_As_int(obj1));
22803         if (SWIG_arg_fail(2)) SWIG_fail;
22804     }
22805     if (arg1) (arg1)->m_col = arg2;
22806
22807     Py_INCREF(Py_None); resultobj = Py_None;
22808     return resultobj;
22809     fail:
22810     return NULL;
22811 }
22812
22813
22814 static PyObject *_wrap_ListItem_m_col_get(PyObject *, PyObject *args, PyObject *kwargs) {
22815     PyObject *resultobj;
22816     wxListItem *arg1 = (wxListItem *) 0 ;
22817     int result;
22818     PyObject * obj0 = 0 ;
22819     char *kwnames[] = {
22820         (char *) "self", NULL
22821     };
22822
22823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_col_get",kwnames,&obj0)) goto fail;
22824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22825     if (SWIG_arg_fail(1)) SWIG_fail;
22826     result = (int) ((arg1)->m_col);
22827
22828     {
22829         resultobj = SWIG_From_int((int)(result));
22830     }
22831     return resultobj;
22832     fail:
22833     return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_ListItem_m_state_set(PyObject *, PyObject *args, PyObject *kwargs) {
22838     PyObject *resultobj;
22839     wxListItem *arg1 = (wxListItem *) 0 ;
22840     long arg2 ;
22841     PyObject * obj0 = 0 ;
22842     PyObject * obj1 = 0 ;
22843     char *kwnames[] = {
22844         (char *) "self",(char *) "m_state", NULL
22845     };
22846
22847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_state_set",kwnames,&obj0,&obj1)) goto fail;
22848     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22849     if (SWIG_arg_fail(1)) SWIG_fail;
22850     {
22851         arg2 = (long)(SWIG_As_long(obj1));
22852         if (SWIG_arg_fail(2)) SWIG_fail;
22853     }
22854     if (arg1) (arg1)->m_state = arg2;
22855
22856     Py_INCREF(Py_None); resultobj = Py_None;
22857     return resultobj;
22858     fail:
22859     return NULL;
22860 }
22861
22862
22863 static PyObject *_wrap_ListItem_m_state_get(PyObject *, PyObject *args, PyObject *kwargs) {
22864     PyObject *resultobj;
22865     wxListItem *arg1 = (wxListItem *) 0 ;
22866     long result;
22867     PyObject * obj0 = 0 ;
22868     char *kwnames[] = {
22869         (char *) "self", NULL
22870     };
22871
22872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_state_get",kwnames,&obj0)) goto fail;
22873     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22874     if (SWIG_arg_fail(1)) SWIG_fail;
22875     result = (long) ((arg1)->m_state);
22876
22877     {
22878         resultobj = SWIG_From_long((long)(result));
22879     }
22880     return resultobj;
22881     fail:
22882     return NULL;
22883 }
22884
22885
22886 static PyObject *_wrap_ListItem_m_stateMask_set(PyObject *, PyObject *args, PyObject *kwargs) {
22887     PyObject *resultobj;
22888     wxListItem *arg1 = (wxListItem *) 0 ;
22889     long arg2 ;
22890     PyObject * obj0 = 0 ;
22891     PyObject * obj1 = 0 ;
22892     char *kwnames[] = {
22893         (char *) "self",(char *) "m_stateMask", NULL
22894     };
22895
22896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_stateMask_set",kwnames,&obj0,&obj1)) goto fail;
22897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22898     if (SWIG_arg_fail(1)) SWIG_fail;
22899     {
22900         arg2 = (long)(SWIG_As_long(obj1));
22901         if (SWIG_arg_fail(2)) SWIG_fail;
22902     }
22903     if (arg1) (arg1)->m_stateMask = arg2;
22904
22905     Py_INCREF(Py_None); resultobj = Py_None;
22906     return resultobj;
22907     fail:
22908     return NULL;
22909 }
22910
22911
22912 static PyObject *_wrap_ListItem_m_stateMask_get(PyObject *, PyObject *args, PyObject *kwargs) {
22913     PyObject *resultobj;
22914     wxListItem *arg1 = (wxListItem *) 0 ;
22915     long result;
22916     PyObject * obj0 = 0 ;
22917     char *kwnames[] = {
22918         (char *) "self", NULL
22919     };
22920
22921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_stateMask_get",kwnames,&obj0)) goto fail;
22922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22923     if (SWIG_arg_fail(1)) SWIG_fail;
22924     result = (long) ((arg1)->m_stateMask);
22925
22926     {
22927         resultobj = SWIG_From_long((long)(result));
22928     }
22929     return resultobj;
22930     fail:
22931     return NULL;
22932 }
22933
22934
22935 static PyObject *_wrap_ListItem_m_text_set(PyObject *, PyObject *args, PyObject *kwargs) {
22936     PyObject *resultobj;
22937     wxListItem *arg1 = (wxListItem *) 0 ;
22938     wxString *arg2 = (wxString *) 0 ;
22939     bool temp2 = false ;
22940     PyObject * obj0 = 0 ;
22941     PyObject * obj1 = 0 ;
22942     char *kwnames[] = {
22943         (char *) "self",(char *) "m_text", NULL
22944     };
22945
22946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_text_set",kwnames,&obj0,&obj1)) goto fail;
22947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22948     if (SWIG_arg_fail(1)) SWIG_fail;
22949     {
22950         arg2 = wxString_in_helper(obj1);
22951         if (arg2 == NULL) SWIG_fail;
22952         temp2 = true;
22953     }
22954     if (arg1) (arg1)->m_text = *arg2;
22955
22956     Py_INCREF(Py_None); resultobj = Py_None;
22957     {
22958         if (temp2)
22959         delete arg2;
22960     }
22961     return resultobj;
22962     fail:
22963     {
22964         if (temp2)
22965         delete arg2;
22966     }
22967     return NULL;
22968 }
22969
22970
22971 static PyObject *_wrap_ListItem_m_text_get(PyObject *, PyObject *args, PyObject *kwargs) {
22972     PyObject *resultobj;
22973     wxListItem *arg1 = (wxListItem *) 0 ;
22974     wxString *result;
22975     PyObject * obj0 = 0 ;
22976     char *kwnames[] = {
22977         (char *) "self", NULL
22978     };
22979
22980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_text_get",kwnames,&obj0)) goto fail;
22981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22982     if (SWIG_arg_fail(1)) SWIG_fail;
22983     result = (wxString *)& ((arg1)->m_text);
22984
22985     {
22986 #if wxUSE_UNICODE
22987         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22988 #else
22989         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22990 #endif
22991     }
22992     return resultobj;
22993     fail:
22994     return NULL;
22995 }
22996
22997
22998 static PyObject *_wrap_ListItem_m_image_set(PyObject *, PyObject *args, PyObject *kwargs) {
22999     PyObject *resultobj;
23000     wxListItem *arg1 = (wxListItem *) 0 ;
23001     int arg2 ;
23002     PyObject * obj0 = 0 ;
23003     PyObject * obj1 = 0 ;
23004     char *kwnames[] = {
23005         (char *) "self",(char *) "m_image", NULL
23006     };
23007
23008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_image_set",kwnames,&obj0,&obj1)) goto fail;
23009     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23010     if (SWIG_arg_fail(1)) SWIG_fail;
23011     {
23012         arg2 = (int)(SWIG_As_int(obj1));
23013         if (SWIG_arg_fail(2)) SWIG_fail;
23014     }
23015     if (arg1) (arg1)->m_image = arg2;
23016
23017     Py_INCREF(Py_None); resultobj = Py_None;
23018     return resultobj;
23019     fail:
23020     return NULL;
23021 }
23022
23023
23024 static PyObject *_wrap_ListItem_m_image_get(PyObject *, PyObject *args, PyObject *kwargs) {
23025     PyObject *resultobj;
23026     wxListItem *arg1 = (wxListItem *) 0 ;
23027     int result;
23028     PyObject * obj0 = 0 ;
23029     char *kwnames[] = {
23030         (char *) "self", NULL
23031     };
23032
23033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_image_get",kwnames,&obj0)) goto fail;
23034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23035     if (SWIG_arg_fail(1)) SWIG_fail;
23036     result = (int) ((arg1)->m_image);
23037
23038     {
23039         resultobj = SWIG_From_int((int)(result));
23040     }
23041     return resultobj;
23042     fail:
23043     return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_ListItem_m_data_set(PyObject *, PyObject *args, PyObject *kwargs) {
23048     PyObject *resultobj;
23049     wxListItem *arg1 = (wxListItem *) 0 ;
23050     long arg2 ;
23051     PyObject * obj0 = 0 ;
23052     PyObject * obj1 = 0 ;
23053     char *kwnames[] = {
23054         (char *) "self",(char *) "m_data", NULL
23055     };
23056
23057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_data_set",kwnames,&obj0,&obj1)) goto fail;
23058     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23059     if (SWIG_arg_fail(1)) SWIG_fail;
23060     {
23061         arg2 = (long)(SWIG_As_long(obj1));
23062         if (SWIG_arg_fail(2)) SWIG_fail;
23063     }
23064     if (arg1) (arg1)->m_data = arg2;
23065
23066     Py_INCREF(Py_None); resultobj = Py_None;
23067     return resultobj;
23068     fail:
23069     return NULL;
23070 }
23071
23072
23073 static PyObject *_wrap_ListItem_m_data_get(PyObject *, PyObject *args, PyObject *kwargs) {
23074     PyObject *resultobj;
23075     wxListItem *arg1 = (wxListItem *) 0 ;
23076     long result;
23077     PyObject * obj0 = 0 ;
23078     char *kwnames[] = {
23079         (char *) "self", NULL
23080     };
23081
23082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_data_get",kwnames,&obj0)) goto fail;
23083     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23084     if (SWIG_arg_fail(1)) SWIG_fail;
23085     result = (long) ((arg1)->m_data);
23086
23087     {
23088         resultobj = SWIG_From_long((long)(result));
23089     }
23090     return resultobj;
23091     fail:
23092     return NULL;
23093 }
23094
23095
23096 static PyObject *_wrap_ListItem_m_format_set(PyObject *, PyObject *args, PyObject *kwargs) {
23097     PyObject *resultobj;
23098     wxListItem *arg1 = (wxListItem *) 0 ;
23099     int arg2 ;
23100     PyObject * obj0 = 0 ;
23101     PyObject * obj1 = 0 ;
23102     char *kwnames[] = {
23103         (char *) "self",(char *) "m_format", NULL
23104     };
23105
23106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_format_set",kwnames,&obj0,&obj1)) goto fail;
23107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23108     if (SWIG_arg_fail(1)) SWIG_fail;
23109     {
23110         arg2 = (int)(SWIG_As_int(obj1));
23111         if (SWIG_arg_fail(2)) SWIG_fail;
23112     }
23113     if (arg1) (arg1)->m_format = arg2;
23114
23115     Py_INCREF(Py_None); resultobj = Py_None;
23116     return resultobj;
23117     fail:
23118     return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_ListItem_m_format_get(PyObject *, PyObject *args, PyObject *kwargs) {
23123     PyObject *resultobj;
23124     wxListItem *arg1 = (wxListItem *) 0 ;
23125     int result;
23126     PyObject * obj0 = 0 ;
23127     char *kwnames[] = {
23128         (char *) "self", NULL
23129     };
23130
23131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_format_get",kwnames,&obj0)) goto fail;
23132     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23133     if (SWIG_arg_fail(1)) SWIG_fail;
23134     result = (int) ((arg1)->m_format);
23135
23136     {
23137         resultobj = SWIG_From_int((int)(result));
23138     }
23139     return resultobj;
23140     fail:
23141     return NULL;
23142 }
23143
23144
23145 static PyObject *_wrap_ListItem_m_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
23146     PyObject *resultobj;
23147     wxListItem *arg1 = (wxListItem *) 0 ;
23148     int arg2 ;
23149     PyObject * obj0 = 0 ;
23150     PyObject * obj1 = 0 ;
23151     char *kwnames[] = {
23152         (char *) "self",(char *) "m_width", NULL
23153     };
23154
23155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_width_set",kwnames,&obj0,&obj1)) goto fail;
23156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23157     if (SWIG_arg_fail(1)) SWIG_fail;
23158     {
23159         arg2 = (int)(SWIG_As_int(obj1));
23160         if (SWIG_arg_fail(2)) SWIG_fail;
23161     }
23162     if (arg1) (arg1)->m_width = arg2;
23163
23164     Py_INCREF(Py_None); resultobj = Py_None;
23165     return resultobj;
23166     fail:
23167     return NULL;
23168 }
23169
23170
23171 static PyObject *_wrap_ListItem_m_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
23172     PyObject *resultobj;
23173     wxListItem *arg1 = (wxListItem *) 0 ;
23174     int result;
23175     PyObject * obj0 = 0 ;
23176     char *kwnames[] = {
23177         (char *) "self", NULL
23178     };
23179
23180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_width_get",kwnames,&obj0)) goto fail;
23181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23182     if (SWIG_arg_fail(1)) SWIG_fail;
23183     result = (int) ((arg1)->m_width);
23184
23185     {
23186         resultobj = SWIG_From_int((int)(result));
23187     }
23188     return resultobj;
23189     fail:
23190     return NULL;
23191 }
23192
23193
23194 static PyObject * ListItem_swigregister(PyObject *, PyObject *args) {
23195     PyObject *obj;
23196     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23197     SWIG_TypeClientData(SWIGTYPE_p_wxListItem, obj);
23198     Py_INCREF(obj);
23199     return Py_BuildValue((char *)"");
23200 }
23201 static PyObject *_wrap_new_ListEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23202     PyObject *resultobj;
23203     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23204     int arg2 = (int) 0 ;
23205     wxListEvent *result;
23206     PyObject * obj0 = 0 ;
23207     PyObject * obj1 = 0 ;
23208     char *kwnames[] = {
23209         (char *) "commandType",(char *) "id", NULL
23210     };
23211
23212     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ListEvent",kwnames,&obj0,&obj1)) goto fail;
23213     if (obj0) {
23214         {
23215             arg1 = (wxEventType)(SWIG_As_int(obj0));
23216             if (SWIG_arg_fail(1)) SWIG_fail;
23217         }
23218     }
23219     if (obj1) {
23220         {
23221             arg2 = (int)(SWIG_As_int(obj1));
23222             if (SWIG_arg_fail(2)) SWIG_fail;
23223         }
23224     }
23225     {
23226         PyThreadState* __tstate = wxPyBeginAllowThreads();
23227         result = (wxListEvent *)new wxListEvent(arg1,arg2);
23228
23229         wxPyEndAllowThreads(__tstate);
23230         if (PyErr_Occurred()) SWIG_fail;
23231     }
23232     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListEvent, 1);
23233     return resultobj;
23234     fail:
23235     return NULL;
23236 }
23237
23238
23239 static PyObject *_wrap_ListEvent_m_code_set(PyObject *, PyObject *args, PyObject *kwargs) {
23240     PyObject *resultobj;
23241     wxListEvent *arg1 = (wxListEvent *) 0 ;
23242     int arg2 ;
23243     PyObject * obj0 = 0 ;
23244     PyObject * obj1 = 0 ;
23245     char *kwnames[] = {
23246         (char *) "self",(char *) "m_code", NULL
23247     };
23248
23249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_code_set",kwnames,&obj0,&obj1)) goto fail;
23250     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23251     if (SWIG_arg_fail(1)) SWIG_fail;
23252     {
23253         arg2 = (int)(SWIG_As_int(obj1));
23254         if (SWIG_arg_fail(2)) SWIG_fail;
23255     }
23256     if (arg1) (arg1)->m_code = arg2;
23257
23258     Py_INCREF(Py_None); resultobj = Py_None;
23259     return resultobj;
23260     fail:
23261     return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_ListEvent_m_code_get(PyObject *, PyObject *args, PyObject *kwargs) {
23266     PyObject *resultobj;
23267     wxListEvent *arg1 = (wxListEvent *) 0 ;
23268     int result;
23269     PyObject * obj0 = 0 ;
23270     char *kwnames[] = {
23271         (char *) "self", NULL
23272     };
23273
23274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_code_get",kwnames,&obj0)) goto fail;
23275     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23276     if (SWIG_arg_fail(1)) SWIG_fail;
23277     result = (int) ((arg1)->m_code);
23278
23279     {
23280         resultobj = SWIG_From_int((int)(result));
23281     }
23282     return resultobj;
23283     fail:
23284     return NULL;
23285 }
23286
23287
23288 static PyObject *_wrap_ListEvent_m_oldItemIndex_set(PyObject *, PyObject *args, PyObject *kwargs) {
23289     PyObject *resultobj;
23290     wxListEvent *arg1 = (wxListEvent *) 0 ;
23291     long arg2 ;
23292     PyObject * obj0 = 0 ;
23293     PyObject * obj1 = 0 ;
23294     char *kwnames[] = {
23295         (char *) "self",(char *) "m_oldItemIndex", NULL
23296     };
23297
23298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_oldItemIndex_set",kwnames,&obj0,&obj1)) goto fail;
23299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23300     if (SWIG_arg_fail(1)) SWIG_fail;
23301     {
23302         arg2 = (long)(SWIG_As_long(obj1));
23303         if (SWIG_arg_fail(2)) SWIG_fail;
23304     }
23305     if (arg1) (arg1)->m_oldItemIndex = arg2;
23306
23307     Py_INCREF(Py_None); resultobj = Py_None;
23308     return resultobj;
23309     fail:
23310     return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_ListEvent_m_oldItemIndex_get(PyObject *, PyObject *args, PyObject *kwargs) {
23315     PyObject *resultobj;
23316     wxListEvent *arg1 = (wxListEvent *) 0 ;
23317     long result;
23318     PyObject * obj0 = 0 ;
23319     char *kwnames[] = {
23320         (char *) "self", NULL
23321     };
23322
23323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_oldItemIndex_get",kwnames,&obj0)) goto fail;
23324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23325     if (SWIG_arg_fail(1)) SWIG_fail;
23326     result = (long) ((arg1)->m_oldItemIndex);
23327
23328     {
23329         resultobj = SWIG_From_long((long)(result));
23330     }
23331     return resultobj;
23332     fail:
23333     return NULL;
23334 }
23335
23336
23337 static PyObject *_wrap_ListEvent_m_itemIndex_set(PyObject *, PyObject *args, PyObject *kwargs) {
23338     PyObject *resultobj;
23339     wxListEvent *arg1 = (wxListEvent *) 0 ;
23340     long arg2 ;
23341     PyObject * obj0 = 0 ;
23342     PyObject * obj1 = 0 ;
23343     char *kwnames[] = {
23344         (char *) "self",(char *) "m_itemIndex", NULL
23345     };
23346
23347     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_itemIndex_set",kwnames,&obj0,&obj1)) goto fail;
23348     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23349     if (SWIG_arg_fail(1)) SWIG_fail;
23350     {
23351         arg2 = (long)(SWIG_As_long(obj1));
23352         if (SWIG_arg_fail(2)) SWIG_fail;
23353     }
23354     if (arg1) (arg1)->m_itemIndex = arg2;
23355
23356     Py_INCREF(Py_None); resultobj = Py_None;
23357     return resultobj;
23358     fail:
23359     return NULL;
23360 }
23361
23362
23363 static PyObject *_wrap_ListEvent_m_itemIndex_get(PyObject *, PyObject *args, PyObject *kwargs) {
23364     PyObject *resultobj;
23365     wxListEvent *arg1 = (wxListEvent *) 0 ;
23366     long result;
23367     PyObject * obj0 = 0 ;
23368     char *kwnames[] = {
23369         (char *) "self", NULL
23370     };
23371
23372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_itemIndex_get",kwnames,&obj0)) goto fail;
23373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23374     if (SWIG_arg_fail(1)) SWIG_fail;
23375     result = (long) ((arg1)->m_itemIndex);
23376
23377     {
23378         resultobj = SWIG_From_long((long)(result));
23379     }
23380     return resultobj;
23381     fail:
23382     return NULL;
23383 }
23384
23385
23386 static PyObject *_wrap_ListEvent_m_col_set(PyObject *, PyObject *args, PyObject *kwargs) {
23387     PyObject *resultobj;
23388     wxListEvent *arg1 = (wxListEvent *) 0 ;
23389     int arg2 ;
23390     PyObject * obj0 = 0 ;
23391     PyObject * obj1 = 0 ;
23392     char *kwnames[] = {
23393         (char *) "self",(char *) "m_col", NULL
23394     };
23395
23396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_col_set",kwnames,&obj0,&obj1)) goto fail;
23397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23398     if (SWIG_arg_fail(1)) SWIG_fail;
23399     {
23400         arg2 = (int)(SWIG_As_int(obj1));
23401         if (SWIG_arg_fail(2)) SWIG_fail;
23402     }
23403     if (arg1) (arg1)->m_col = arg2;
23404
23405     Py_INCREF(Py_None); resultobj = Py_None;
23406     return resultobj;
23407     fail:
23408     return NULL;
23409 }
23410
23411
23412 static PyObject *_wrap_ListEvent_m_col_get(PyObject *, PyObject *args, PyObject *kwargs) {
23413     PyObject *resultobj;
23414     wxListEvent *arg1 = (wxListEvent *) 0 ;
23415     int result;
23416     PyObject * obj0 = 0 ;
23417     char *kwnames[] = {
23418         (char *) "self", NULL
23419     };
23420
23421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_col_get",kwnames,&obj0)) goto fail;
23422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23423     if (SWIG_arg_fail(1)) SWIG_fail;
23424     result = (int) ((arg1)->m_col);
23425
23426     {
23427         resultobj = SWIG_From_int((int)(result));
23428     }
23429     return resultobj;
23430     fail:
23431     return NULL;
23432 }
23433
23434
23435 static PyObject *_wrap_ListEvent_m_pointDrag_set(PyObject *, PyObject *args, PyObject *kwargs) {
23436     PyObject *resultobj;
23437     wxListEvent *arg1 = (wxListEvent *) 0 ;
23438     wxPoint *arg2 = (wxPoint *) 0 ;
23439     PyObject * obj0 = 0 ;
23440     PyObject * obj1 = 0 ;
23441     char *kwnames[] = {
23442         (char *) "self",(char *) "m_pointDrag", NULL
23443     };
23444
23445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_pointDrag_set",kwnames,&obj0,&obj1)) goto fail;
23446     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23447     if (SWIG_arg_fail(1)) SWIG_fail;
23448     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
23449     if (SWIG_arg_fail(2)) SWIG_fail;
23450     if (arg1) (arg1)->m_pointDrag = *arg2;
23451
23452     Py_INCREF(Py_None); resultobj = Py_None;
23453     return resultobj;
23454     fail:
23455     return NULL;
23456 }
23457
23458
23459 static PyObject *_wrap_ListEvent_m_pointDrag_get(PyObject *, PyObject *args, PyObject *kwargs) {
23460     PyObject *resultobj;
23461     wxListEvent *arg1 = (wxListEvent *) 0 ;
23462     wxPoint *result;
23463     PyObject * obj0 = 0 ;
23464     char *kwnames[] = {
23465         (char *) "self", NULL
23466     };
23467
23468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_pointDrag_get",kwnames,&obj0)) goto fail;
23469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23470     if (SWIG_arg_fail(1)) SWIG_fail;
23471     result = (wxPoint *)& ((arg1)->m_pointDrag);
23472
23473     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
23474     return resultobj;
23475     fail:
23476     return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_ListEvent_m_item_get(PyObject *, PyObject *args, PyObject *kwargs) {
23481     PyObject *resultobj;
23482     wxListEvent *arg1 = (wxListEvent *) 0 ;
23483     wxListItem *result;
23484     PyObject * obj0 = 0 ;
23485     char *kwnames[] = {
23486         (char *) "self", NULL
23487     };
23488
23489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_item_get",kwnames,&obj0)) goto fail;
23490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23491     if (SWIG_arg_fail(1)) SWIG_fail;
23492     result = (wxListItem *)& ((arg1)->m_item);
23493
23494     {
23495         resultobj = wxPyMake_wxObject(result, 0);
23496     }
23497     return resultobj;
23498     fail:
23499     return NULL;
23500 }
23501
23502
23503 static PyObject *_wrap_ListEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23504     PyObject *resultobj;
23505     wxListEvent *arg1 = (wxListEvent *) 0 ;
23506     int result;
23507     PyObject * obj0 = 0 ;
23508     char *kwnames[] = {
23509         (char *) "self", NULL
23510     };
23511
23512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetKeyCode",kwnames,&obj0)) goto fail;
23513     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23514     if (SWIG_arg_fail(1)) SWIG_fail;
23515     {
23516         PyThreadState* __tstate = wxPyBeginAllowThreads();
23517         result = (int)(arg1)->GetKeyCode();
23518
23519         wxPyEndAllowThreads(__tstate);
23520         if (PyErr_Occurred()) SWIG_fail;
23521     }
23522     {
23523         resultobj = SWIG_From_int((int)(result));
23524     }
23525     return resultobj;
23526     fail:
23527     return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_ListEvent_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
23532     PyObject *resultobj;
23533     wxListEvent *arg1 = (wxListEvent *) 0 ;
23534     long result;
23535     PyObject * obj0 = 0 ;
23536     char *kwnames[] = {
23537         (char *) "self", NULL
23538     };
23539
23540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetIndex",kwnames,&obj0)) goto fail;
23541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23542     if (SWIG_arg_fail(1)) SWIG_fail;
23543     {
23544         PyThreadState* __tstate = wxPyBeginAllowThreads();
23545         result = (long)(arg1)->GetIndex();
23546
23547         wxPyEndAllowThreads(__tstate);
23548         if (PyErr_Occurred()) SWIG_fail;
23549     }
23550     {
23551         resultobj = SWIG_From_long((long)(result));
23552     }
23553     return resultobj;
23554     fail:
23555     return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_ListEvent_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
23560     PyObject *resultobj;
23561     wxListEvent *arg1 = (wxListEvent *) 0 ;
23562     int result;
23563     PyObject * obj0 = 0 ;
23564     char *kwnames[] = {
23565         (char *) "self", NULL
23566     };
23567
23568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetColumn",kwnames,&obj0)) goto fail;
23569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23570     if (SWIG_arg_fail(1)) SWIG_fail;
23571     {
23572         PyThreadState* __tstate = wxPyBeginAllowThreads();
23573         result = (int)(arg1)->GetColumn();
23574
23575         wxPyEndAllowThreads(__tstate);
23576         if (PyErr_Occurred()) SWIG_fail;
23577     }
23578     {
23579         resultobj = SWIG_From_int((int)(result));
23580     }
23581     return resultobj;
23582     fail:
23583     return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_ListEvent_GetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
23588     PyObject *resultobj;
23589     wxListEvent *arg1 = (wxListEvent *) 0 ;
23590     wxPoint result;
23591     PyObject * obj0 = 0 ;
23592     char *kwnames[] = {
23593         (char *) "self", NULL
23594     };
23595
23596     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetPoint",kwnames,&obj0)) goto fail;
23597     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23598     if (SWIG_arg_fail(1)) SWIG_fail;
23599     {
23600         PyThreadState* __tstate = wxPyBeginAllowThreads();
23601         result = (arg1)->GetPoint();
23602
23603         wxPyEndAllowThreads(__tstate);
23604         if (PyErr_Occurred()) SWIG_fail;
23605     }
23606     {
23607         wxPoint * resultptr;
23608         resultptr = new wxPoint((wxPoint &)(result));
23609         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
23610     }
23611     return resultobj;
23612     fail:
23613     return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_ListEvent_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
23618     PyObject *resultobj;
23619     wxListEvent *arg1 = (wxListEvent *) 0 ;
23620     wxString *result;
23621     PyObject * obj0 = 0 ;
23622     char *kwnames[] = {
23623         (char *) "self", NULL
23624     };
23625
23626     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetLabel",kwnames,&obj0)) goto fail;
23627     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23628     if (SWIG_arg_fail(1)) SWIG_fail;
23629     {
23630         PyThreadState* __tstate = wxPyBeginAllowThreads();
23631         {
23632             wxString const &_result_ref = (arg1)->GetLabel();
23633             result = (wxString *) &_result_ref;
23634         }
23635
23636         wxPyEndAllowThreads(__tstate);
23637         if (PyErr_Occurred()) SWIG_fail;
23638     }
23639     {
23640 #if wxUSE_UNICODE
23641         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23642 #else
23643         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23644 #endif
23645     }
23646     return resultobj;
23647     fail:
23648     return NULL;
23649 }
23650
23651
23652 static PyObject *_wrap_ListEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
23653     PyObject *resultobj;
23654     wxListEvent *arg1 = (wxListEvent *) 0 ;
23655     wxString *result;
23656     PyObject * obj0 = 0 ;
23657     char *kwnames[] = {
23658         (char *) "self", NULL
23659     };
23660
23661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetText",kwnames,&obj0)) goto fail;
23662     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23663     if (SWIG_arg_fail(1)) SWIG_fail;
23664     {
23665         PyThreadState* __tstate = wxPyBeginAllowThreads();
23666         {
23667             wxString const &_result_ref = (arg1)->GetText();
23668             result = (wxString *) &_result_ref;
23669         }
23670
23671         wxPyEndAllowThreads(__tstate);
23672         if (PyErr_Occurred()) SWIG_fail;
23673     }
23674     {
23675 #if wxUSE_UNICODE
23676         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23677 #else
23678         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23679 #endif
23680     }
23681     return resultobj;
23682     fail:
23683     return NULL;
23684 }
23685
23686
23687 static PyObject *_wrap_ListEvent_GetImage(PyObject *, PyObject *args, PyObject *kwargs) {
23688     PyObject *resultobj;
23689     wxListEvent *arg1 = (wxListEvent *) 0 ;
23690     int result;
23691     PyObject * obj0 = 0 ;
23692     char *kwnames[] = {
23693         (char *) "self", NULL
23694     };
23695
23696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetImage",kwnames,&obj0)) goto fail;
23697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23698     if (SWIG_arg_fail(1)) SWIG_fail;
23699     {
23700         PyThreadState* __tstate = wxPyBeginAllowThreads();
23701         result = (int)(arg1)->GetImage();
23702
23703         wxPyEndAllowThreads(__tstate);
23704         if (PyErr_Occurred()) SWIG_fail;
23705     }
23706     {
23707         resultobj = SWIG_From_int((int)(result));
23708     }
23709     return resultobj;
23710     fail:
23711     return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_ListEvent_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
23716     PyObject *resultobj;
23717     wxListEvent *arg1 = (wxListEvent *) 0 ;
23718     long result;
23719     PyObject * obj0 = 0 ;
23720     char *kwnames[] = {
23721         (char *) "self", NULL
23722     };
23723
23724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetData",kwnames,&obj0)) goto fail;
23725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23726     if (SWIG_arg_fail(1)) SWIG_fail;
23727     {
23728         PyThreadState* __tstate = wxPyBeginAllowThreads();
23729         result = (long)(arg1)->GetData();
23730
23731         wxPyEndAllowThreads(__tstate);
23732         if (PyErr_Occurred()) SWIG_fail;
23733     }
23734     {
23735         resultobj = SWIG_From_long((long)(result));
23736     }
23737     return resultobj;
23738     fail:
23739     return NULL;
23740 }
23741
23742
23743 static PyObject *_wrap_ListEvent_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
23744     PyObject *resultobj;
23745     wxListEvent *arg1 = (wxListEvent *) 0 ;
23746     long result;
23747     PyObject * obj0 = 0 ;
23748     char *kwnames[] = {
23749         (char *) "self", NULL
23750     };
23751
23752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetMask",kwnames,&obj0)) goto fail;
23753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23754     if (SWIG_arg_fail(1)) SWIG_fail;
23755     {
23756         PyThreadState* __tstate = wxPyBeginAllowThreads();
23757         result = (long)(arg1)->GetMask();
23758
23759         wxPyEndAllowThreads(__tstate);
23760         if (PyErr_Occurred()) SWIG_fail;
23761     }
23762     {
23763         resultobj = SWIG_From_long((long)(result));
23764     }
23765     return resultobj;
23766     fail:
23767     return NULL;
23768 }
23769
23770
23771 static PyObject *_wrap_ListEvent_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
23772     PyObject *resultobj;
23773     wxListEvent *arg1 = (wxListEvent *) 0 ;
23774     wxListItem *result;
23775     PyObject * obj0 = 0 ;
23776     char *kwnames[] = {
23777         (char *) "self", NULL
23778     };
23779
23780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetItem",kwnames,&obj0)) goto fail;
23781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23782     if (SWIG_arg_fail(1)) SWIG_fail;
23783     {
23784         PyThreadState* __tstate = wxPyBeginAllowThreads();
23785         {
23786             wxListItem const &_result_ref = (arg1)->GetItem();
23787             result = (wxListItem *) &_result_ref;
23788         }
23789
23790         wxPyEndAllowThreads(__tstate);
23791         if (PyErr_Occurred()) SWIG_fail;
23792     }
23793     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItem, 0);
23794     return resultobj;
23795     fail:
23796     return NULL;
23797 }
23798
23799
23800 static PyObject *_wrap_ListEvent_GetCacheFrom(PyObject *, PyObject *args, PyObject *kwargs) {
23801     PyObject *resultobj;
23802     wxListEvent *arg1 = (wxListEvent *) 0 ;
23803     long result;
23804     PyObject * obj0 = 0 ;
23805     char *kwnames[] = {
23806         (char *) "self", NULL
23807     };
23808
23809     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetCacheFrom",kwnames,&obj0)) goto fail;
23810     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23811     if (SWIG_arg_fail(1)) SWIG_fail;
23812     {
23813         PyThreadState* __tstate = wxPyBeginAllowThreads();
23814         result = (long)(arg1)->GetCacheFrom();
23815
23816         wxPyEndAllowThreads(__tstate);
23817         if (PyErr_Occurred()) SWIG_fail;
23818     }
23819     {
23820         resultobj = SWIG_From_long((long)(result));
23821     }
23822     return resultobj;
23823     fail:
23824     return NULL;
23825 }
23826
23827
23828 static PyObject *_wrap_ListEvent_GetCacheTo(PyObject *, PyObject *args, PyObject *kwargs) {
23829     PyObject *resultobj;
23830     wxListEvent *arg1 = (wxListEvent *) 0 ;
23831     long result;
23832     PyObject * obj0 = 0 ;
23833     char *kwnames[] = {
23834         (char *) "self", NULL
23835     };
23836
23837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetCacheTo",kwnames,&obj0)) goto fail;
23838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23839     if (SWIG_arg_fail(1)) SWIG_fail;
23840     {
23841         PyThreadState* __tstate = wxPyBeginAllowThreads();
23842         result = (long)(arg1)->GetCacheTo();
23843
23844         wxPyEndAllowThreads(__tstate);
23845         if (PyErr_Occurred()) SWIG_fail;
23846     }
23847     {
23848         resultobj = SWIG_From_long((long)(result));
23849     }
23850     return resultobj;
23851     fail:
23852     return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_ListEvent_IsEditCancelled(PyObject *, PyObject *args, PyObject *kwargs) {
23857     PyObject *resultobj;
23858     wxListEvent *arg1 = (wxListEvent *) 0 ;
23859     bool result;
23860     PyObject * obj0 = 0 ;
23861     char *kwnames[] = {
23862         (char *) "self", NULL
23863     };
23864
23865     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_IsEditCancelled",kwnames,&obj0)) goto fail;
23866     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23867     if (SWIG_arg_fail(1)) SWIG_fail;
23868     {
23869         PyThreadState* __tstate = wxPyBeginAllowThreads();
23870         result = (bool)((wxListEvent const *)arg1)->IsEditCancelled();
23871
23872         wxPyEndAllowThreads(__tstate);
23873         if (PyErr_Occurred()) SWIG_fail;
23874     }
23875     {
23876         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23877     }
23878     return resultobj;
23879     fail:
23880     return NULL;
23881 }
23882
23883
23884 static PyObject *_wrap_ListEvent_SetEditCanceled(PyObject *, PyObject *args, PyObject *kwargs) {
23885     PyObject *resultobj;
23886     wxListEvent *arg1 = (wxListEvent *) 0 ;
23887     bool arg2 ;
23888     PyObject * obj0 = 0 ;
23889     PyObject * obj1 = 0 ;
23890     char *kwnames[] = {
23891         (char *) "self",(char *) "editCancelled", NULL
23892     };
23893
23894     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_SetEditCanceled",kwnames,&obj0,&obj1)) goto fail;
23895     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23896     if (SWIG_arg_fail(1)) SWIG_fail;
23897     {
23898         arg2 = (bool)(SWIG_As_bool(obj1));
23899         if (SWIG_arg_fail(2)) SWIG_fail;
23900     }
23901     {
23902         PyThreadState* __tstate = wxPyBeginAllowThreads();
23903         (arg1)->SetEditCanceled(arg2);
23904
23905         wxPyEndAllowThreads(__tstate);
23906         if (PyErr_Occurred()) SWIG_fail;
23907     }
23908     Py_INCREF(Py_None); resultobj = Py_None;
23909     return resultobj;
23910     fail:
23911     return NULL;
23912 }
23913
23914
23915 static PyObject * ListEvent_swigregister(PyObject *, PyObject *args) {
23916     PyObject *obj;
23917     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23918     SWIG_TypeClientData(SWIGTYPE_p_wxListEvent, obj);
23919     Py_INCREF(obj);
23920     return Py_BuildValue((char *)"");
23921 }
23922 static PyObject *_wrap_new_ListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
23923     PyObject *resultobj;
23924     wxWindow *arg1 = (wxWindow *) 0 ;
23925     int arg2 = (int) -1 ;
23926     wxPoint const &arg3_defvalue = wxDefaultPosition ;
23927     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
23928     wxSize const &arg4_defvalue = wxDefaultSize ;
23929     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
23930     long arg5 = (long) wxLC_ICON ;
23931     wxValidator const &arg6_defvalue = wxDefaultValidator ;
23932     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
23933     wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
23934     wxString *arg7 = (wxString *) &arg7_defvalue ;
23935     wxPyListCtrl *result;
23936     wxPoint temp3 ;
23937     wxSize temp4 ;
23938     bool temp7 = false ;
23939     PyObject * obj0 = 0 ;
23940     PyObject * obj1 = 0 ;
23941     PyObject * obj2 = 0 ;
23942     PyObject * obj3 = 0 ;
23943     PyObject * obj4 = 0 ;
23944     PyObject * obj5 = 0 ;
23945     PyObject * obj6 = 0 ;
23946     char *kwnames[] = {
23947         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
23948     };
23949
23950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
23951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23952     if (SWIG_arg_fail(1)) SWIG_fail;
23953     if (obj1) {
23954         {
23955             arg2 = (int)(SWIG_As_int(obj1));
23956             if (SWIG_arg_fail(2)) SWIG_fail;
23957         }
23958     }
23959     if (obj2) {
23960         {
23961             arg3 = &temp3;
23962             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
23963         }
23964     }
23965     if (obj3) {
23966         {
23967             arg4 = &temp4;
23968             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
23969         }
23970     }
23971     if (obj4) {
23972         {
23973             arg5 = (long)(SWIG_As_long(obj4));
23974             if (SWIG_arg_fail(5)) SWIG_fail;
23975         }
23976     }
23977     if (obj5) {
23978         {
23979             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
23980             if (SWIG_arg_fail(6)) SWIG_fail;
23981             if (arg6 == NULL) {
23982                 SWIG_null_ref("wxValidator");
23983             }
23984             if (SWIG_arg_fail(6)) SWIG_fail;
23985         }
23986     }
23987     if (obj6) {
23988         {
23989             arg7 = wxString_in_helper(obj6);
23990             if (arg7 == NULL) SWIG_fail;
23991             temp7 = true;
23992         }
23993     }
23994     {
23995         if (!wxPyCheckForApp()) SWIG_fail;
23996         PyThreadState* __tstate = wxPyBeginAllowThreads();
23997         result = (wxPyListCtrl *)new wxPyListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
23998
23999         wxPyEndAllowThreads(__tstate);
24000         if (PyErr_Occurred()) SWIG_fail;
24001     }
24002     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyListCtrl, 1);
24003     {
24004         if (temp7)
24005         delete arg7;
24006     }
24007     return resultobj;
24008     fail:
24009     {
24010         if (temp7)
24011         delete arg7;
24012     }
24013     return NULL;
24014 }
24015
24016
24017 static PyObject *_wrap_new_PreListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
24018     PyObject *resultobj;
24019     wxPyListCtrl *result;
24020     char *kwnames[] = {
24021         NULL
24022     };
24023
24024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListCtrl",kwnames)) goto fail;
24025     {
24026         if (!wxPyCheckForApp()) SWIG_fail;
24027         PyThreadState* __tstate = wxPyBeginAllowThreads();
24028         result = (wxPyListCtrl *)new wxPyListCtrl();
24029
24030         wxPyEndAllowThreads(__tstate);
24031         if (PyErr_Occurred()) SWIG_fail;
24032     }
24033     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyListCtrl, 1);
24034     return resultobj;
24035     fail:
24036     return NULL;
24037 }
24038
24039
24040 static PyObject *_wrap_ListCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24041     PyObject *resultobj;
24042     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24043     wxWindow *arg2 = (wxWindow *) 0 ;
24044     int arg3 = (int) -1 ;
24045     wxPoint const &arg4_defvalue = wxDefaultPosition ;
24046     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24047     wxSize const &arg5_defvalue = wxDefaultSize ;
24048     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24049     long arg6 = (long) wxLC_ICON ;
24050     wxValidator const &arg7_defvalue = wxDefaultValidator ;
24051     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
24052     wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
24053     wxString *arg8 = (wxString *) &arg8_defvalue ;
24054     bool result;
24055     wxPoint temp4 ;
24056     wxSize temp5 ;
24057     bool temp8 = false ;
24058     PyObject * obj0 = 0 ;
24059     PyObject * obj1 = 0 ;
24060     PyObject * obj2 = 0 ;
24061     PyObject * obj3 = 0 ;
24062     PyObject * obj4 = 0 ;
24063     PyObject * obj5 = 0 ;
24064     PyObject * obj6 = 0 ;
24065     PyObject * obj7 = 0 ;
24066     char *kwnames[] = {
24067         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
24068     };
24069
24070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
24071     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24072     if (SWIG_arg_fail(1)) SWIG_fail;
24073     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24074     if (SWIG_arg_fail(2)) SWIG_fail;
24075     if (obj2) {
24076         {
24077             arg3 = (int)(SWIG_As_int(obj2));
24078             if (SWIG_arg_fail(3)) SWIG_fail;
24079         }
24080     }
24081     if (obj3) {
24082         {
24083             arg4 = &temp4;
24084             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24085         }
24086     }
24087     if (obj4) {
24088         {
24089             arg5 = &temp5;
24090             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24091         }
24092     }
24093     if (obj5) {
24094         {
24095             arg6 = (long)(SWIG_As_long(obj5));
24096             if (SWIG_arg_fail(6)) SWIG_fail;
24097         }
24098     }
24099     if (obj6) {
24100         {
24101             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
24102             if (SWIG_arg_fail(7)) SWIG_fail;
24103             if (arg7 == NULL) {
24104                 SWIG_null_ref("wxValidator");
24105             }
24106             if (SWIG_arg_fail(7)) SWIG_fail;
24107         }
24108     }
24109     if (obj7) {
24110         {
24111             arg8 = wxString_in_helper(obj7);
24112             if (arg8 == NULL) SWIG_fail;
24113             temp8 = true;
24114         }
24115     }
24116     {
24117         PyThreadState* __tstate = wxPyBeginAllowThreads();
24118         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
24119
24120         wxPyEndAllowThreads(__tstate);
24121         if (PyErr_Occurred()) SWIG_fail;
24122     }
24123     {
24124         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24125     }
24126     {
24127         if (temp8)
24128         delete arg8;
24129     }
24130     return resultobj;
24131     fail:
24132     {
24133         if (temp8)
24134         delete arg8;
24135     }
24136     return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_ListCtrl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24141     PyObject *resultobj;
24142     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24143     PyObject *arg2 = (PyObject *) 0 ;
24144     PyObject *arg3 = (PyObject *) 0 ;
24145     PyObject * obj0 = 0 ;
24146     PyObject * obj1 = 0 ;
24147     PyObject * obj2 = 0 ;
24148     char *kwnames[] = {
24149         (char *) "self",(char *) "self",(char *) "_class", NULL
24150     };
24151
24152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24153     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24154     if (SWIG_arg_fail(1)) SWIG_fail;
24155     arg2 = obj1;
24156     arg3 = obj2;
24157     {
24158         PyThreadState* __tstate = wxPyBeginAllowThreads();
24159         (arg1)->_setCallbackInfo(arg2,arg3);
24160
24161         wxPyEndAllowThreads(__tstate);
24162         if (PyErr_Occurred()) SWIG_fail;
24163     }
24164     Py_INCREF(Py_None); resultobj = Py_None;
24165     return resultobj;
24166     fail:
24167     return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_ListCtrl_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
24172     PyObject *resultobj;
24173     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24174     wxColour *arg2 = 0 ;
24175     bool result;
24176     wxColour temp2 ;
24177     PyObject * obj0 = 0 ;
24178     PyObject * obj1 = 0 ;
24179     char *kwnames[] = {
24180         (char *) "self",(char *) "col", NULL
24181     };
24182
24183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
24184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24185     if (SWIG_arg_fail(1)) SWIG_fail;
24186     {
24187         arg2 = &temp2;
24188         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24189     }
24190     {
24191         PyThreadState* __tstate = wxPyBeginAllowThreads();
24192         result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
24193
24194         wxPyEndAllowThreads(__tstate);
24195         if (PyErr_Occurred()) SWIG_fail;
24196     }
24197     {
24198         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24199     }
24200     return resultobj;
24201     fail:
24202     return NULL;
24203 }
24204
24205
24206 static PyObject *_wrap_ListCtrl_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
24207     PyObject *resultobj;
24208     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24209     wxColour *arg2 = 0 ;
24210     bool result;
24211     wxColour temp2 ;
24212     PyObject * obj0 = 0 ;
24213     PyObject * obj1 = 0 ;
24214     char *kwnames[] = {
24215         (char *) "self",(char *) "col", NULL
24216     };
24217
24218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
24219     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24220     if (SWIG_arg_fail(1)) SWIG_fail;
24221     {
24222         arg2 = &temp2;
24223         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24224     }
24225     {
24226         PyThreadState* __tstate = wxPyBeginAllowThreads();
24227         result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
24228
24229         wxPyEndAllowThreads(__tstate);
24230         if (PyErr_Occurred()) SWIG_fail;
24231     }
24232     {
24233         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24234     }
24235     return resultobj;
24236     fail:
24237     return NULL;
24238 }
24239
24240
24241 static PyObject *_wrap_ListCtrl_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
24242     PyObject *resultobj;
24243     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24244     int arg2 ;
24245     wxListItem *result;
24246     PyObject * obj0 = 0 ;
24247     PyObject * obj1 = 0 ;
24248     char *kwnames[] = {
24249         (char *) "self",(char *) "col", NULL
24250     };
24251
24252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumn",kwnames,&obj0,&obj1)) goto fail;
24253     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24254     if (SWIG_arg_fail(1)) SWIG_fail;
24255     {
24256         arg2 = (int)(SWIG_As_int(obj1));
24257         if (SWIG_arg_fail(2)) SWIG_fail;
24258     }
24259     {
24260         PyThreadState* __tstate = wxPyBeginAllowThreads();
24261         result = (wxListItem *)wxPyListCtrl_GetColumn(arg1,arg2);
24262
24263         wxPyEndAllowThreads(__tstate);
24264         if (PyErr_Occurred()) SWIG_fail;
24265     }
24266     {
24267         resultobj = wxPyMake_wxObject(result, 0);
24268     }
24269     return resultobj;
24270     fail:
24271     return NULL;
24272 }
24273
24274
24275 static PyObject *_wrap_ListCtrl_SetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
24276     PyObject *resultobj;
24277     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24278     int arg2 ;
24279     wxListItem *arg3 = 0 ;
24280     bool result;
24281     PyObject * obj0 = 0 ;
24282     PyObject * obj1 = 0 ;
24283     PyObject * obj2 = 0 ;
24284     char *kwnames[] = {
24285         (char *) "self",(char *) "col",(char *) "item", NULL
24286     };
24287
24288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
24289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24290     if (SWIG_arg_fail(1)) SWIG_fail;
24291     {
24292         arg2 = (int)(SWIG_As_int(obj1));
24293         if (SWIG_arg_fail(2)) SWIG_fail;
24294     }
24295     {
24296         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
24297         if (SWIG_arg_fail(3)) SWIG_fail;
24298         if (arg3 == NULL) {
24299             SWIG_null_ref("wxListItem");
24300         }
24301         if (SWIG_arg_fail(3)) SWIG_fail;
24302     }
24303     {
24304         PyThreadState* __tstate = wxPyBeginAllowThreads();
24305         result = (bool)(arg1)->SetColumn(arg2,*arg3);
24306
24307         wxPyEndAllowThreads(__tstate);
24308         if (PyErr_Occurred()) SWIG_fail;
24309     }
24310     {
24311         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24312     }
24313     return resultobj;
24314     fail:
24315     return NULL;
24316 }
24317
24318
24319 static PyObject *_wrap_ListCtrl_GetColumnWidth(PyObject *, PyObject *args, PyObject *kwargs) {
24320     PyObject *resultobj;
24321     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24322     int arg2 ;
24323     int result;
24324     PyObject * obj0 = 0 ;
24325     PyObject * obj1 = 0 ;
24326     char *kwnames[] = {
24327         (char *) "self",(char *) "col", NULL
24328     };
24329
24330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumnWidth",kwnames,&obj0,&obj1)) goto fail;
24331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24332     if (SWIG_arg_fail(1)) SWIG_fail;
24333     {
24334         arg2 = (int)(SWIG_As_int(obj1));
24335         if (SWIG_arg_fail(2)) SWIG_fail;
24336     }
24337     {
24338         PyThreadState* __tstate = wxPyBeginAllowThreads();
24339         result = (int)((wxPyListCtrl const *)arg1)->GetColumnWidth(arg2);
24340
24341         wxPyEndAllowThreads(__tstate);
24342         if (PyErr_Occurred()) SWIG_fail;
24343     }
24344     {
24345         resultobj = SWIG_From_int((int)(result));
24346     }
24347     return resultobj;
24348     fail:
24349     return NULL;
24350 }
24351
24352
24353 static PyObject *_wrap_ListCtrl_SetColumnWidth(PyObject *, PyObject *args, PyObject *kwargs) {
24354     PyObject *resultobj;
24355     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24356     int arg2 ;
24357     int arg3 ;
24358     bool result;
24359     PyObject * obj0 = 0 ;
24360     PyObject * obj1 = 0 ;
24361     PyObject * obj2 = 0 ;
24362     char *kwnames[] = {
24363         (char *) "self",(char *) "col",(char *) "width", NULL
24364     };
24365
24366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumnWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
24367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24368     if (SWIG_arg_fail(1)) SWIG_fail;
24369     {
24370         arg2 = (int)(SWIG_As_int(obj1));
24371         if (SWIG_arg_fail(2)) SWIG_fail;
24372     }
24373     {
24374         arg3 = (int)(SWIG_As_int(obj2));
24375         if (SWIG_arg_fail(3)) SWIG_fail;
24376     }
24377     {
24378         PyThreadState* __tstate = wxPyBeginAllowThreads();
24379         result = (bool)(arg1)->SetColumnWidth(arg2,arg3);
24380
24381         wxPyEndAllowThreads(__tstate);
24382         if (PyErr_Occurred()) SWIG_fail;
24383     }
24384     {
24385         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24386     }
24387     return resultobj;
24388     fail:
24389     return NULL;
24390 }
24391
24392
24393 static PyObject *_wrap_ListCtrl_GetCountPerPage(PyObject *, PyObject *args, PyObject *kwargs) {
24394     PyObject *resultobj;
24395     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24396     int result;
24397     PyObject * obj0 = 0 ;
24398     char *kwnames[] = {
24399         (char *) "self", NULL
24400     };
24401
24402     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetCountPerPage",kwnames,&obj0)) goto fail;
24403     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24404     if (SWIG_arg_fail(1)) SWIG_fail;
24405     {
24406         PyThreadState* __tstate = wxPyBeginAllowThreads();
24407         result = (int)((wxPyListCtrl const *)arg1)->GetCountPerPage();
24408
24409         wxPyEndAllowThreads(__tstate);
24410         if (PyErr_Occurred()) SWIG_fail;
24411     }
24412     {
24413         resultobj = SWIG_From_int((int)(result));
24414     }
24415     return resultobj;
24416     fail:
24417     return NULL;
24418 }
24419
24420
24421 static PyObject *_wrap_ListCtrl_GetViewRect(PyObject *, PyObject *args, PyObject *kwargs) {
24422     PyObject *resultobj;
24423     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24424     wxRect result;
24425     PyObject * obj0 = 0 ;
24426     char *kwnames[] = {
24427         (char *) "self", NULL
24428     };
24429
24430     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetViewRect",kwnames,&obj0)) goto fail;
24431     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24432     if (SWIG_arg_fail(1)) SWIG_fail;
24433     {
24434         PyThreadState* __tstate = wxPyBeginAllowThreads();
24435         result = ((wxPyListCtrl const *)arg1)->GetViewRect();
24436
24437         wxPyEndAllowThreads(__tstate);
24438         if (PyErr_Occurred()) SWIG_fail;
24439     }
24440     {
24441         wxRect * resultptr;
24442         resultptr = new wxRect((wxRect &)(result));
24443         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
24444     }
24445     return resultobj;
24446     fail:
24447     return NULL;
24448 }
24449
24450
24451 static PyObject *_wrap_ListCtrl_GetEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
24452     PyObject *resultobj;
24453     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24454     wxTextCtrl *result;
24455     PyObject * obj0 = 0 ;
24456     char *kwnames[] = {
24457         (char *) "self", NULL
24458     };
24459
24460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetEditControl",kwnames,&obj0)) goto fail;
24461     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24462     if (SWIG_arg_fail(1)) SWIG_fail;
24463     {
24464         PyThreadState* __tstate = wxPyBeginAllowThreads();
24465         result = (wxTextCtrl *)((wxPyListCtrl const *)arg1)->GetEditControl();
24466
24467         wxPyEndAllowThreads(__tstate);
24468         if (PyErr_Occurred()) SWIG_fail;
24469     }
24470     {
24471         resultobj = wxPyMake_wxObject(result, 0);
24472     }
24473     return resultobj;
24474     fail:
24475     return NULL;
24476 }
24477
24478
24479 static PyObject *_wrap_ListCtrl_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
24480     PyObject *resultobj;
24481     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24482     long arg2 ;
24483     int arg3 = (int) 0 ;
24484     wxListItem *result;
24485     PyObject * obj0 = 0 ;
24486     PyObject * obj1 = 0 ;
24487     PyObject * obj2 = 0 ;
24488     char *kwnames[] = {
24489         (char *) "self",(char *) "itemId",(char *) "col", NULL
24490     };
24491
24492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
24493     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24494     if (SWIG_arg_fail(1)) SWIG_fail;
24495     {
24496         arg2 = (long)(SWIG_As_long(obj1));
24497         if (SWIG_arg_fail(2)) SWIG_fail;
24498     }
24499     if (obj2) {
24500         {
24501             arg3 = (int)(SWIG_As_int(obj2));
24502             if (SWIG_arg_fail(3)) SWIG_fail;
24503         }
24504     }
24505     {
24506         PyThreadState* __tstate = wxPyBeginAllowThreads();
24507         result = (wxListItem *)wxPyListCtrl_GetItem(arg1,arg2,arg3);
24508
24509         wxPyEndAllowThreads(__tstate);
24510         if (PyErr_Occurred()) SWIG_fail;
24511     }
24512     {
24513         resultobj = wxPyMake_wxObject(result, 0);
24514     }
24515     return resultobj;
24516     fail:
24517     return NULL;
24518 }
24519
24520
24521 static PyObject *_wrap_ListCtrl_SetItem(PyObject *, PyObject *args, PyObject *kwargs) {
24522     PyObject *resultobj;
24523     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24524     wxListItem *arg2 = 0 ;
24525     bool result;
24526     PyObject * obj0 = 0 ;
24527     PyObject * obj1 = 0 ;
24528     char *kwnames[] = {
24529         (char *) "self",(char *) "info", NULL
24530     };
24531
24532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItem",kwnames,&obj0,&obj1)) goto fail;
24533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24534     if (SWIG_arg_fail(1)) SWIG_fail;
24535     {
24536         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
24537         if (SWIG_arg_fail(2)) SWIG_fail;
24538         if (arg2 == NULL) {
24539             SWIG_null_ref("wxListItem");
24540         }
24541         if (SWIG_arg_fail(2)) SWIG_fail;
24542     }
24543     {
24544         PyThreadState* __tstate = wxPyBeginAllowThreads();
24545         result = (bool)(arg1)->SetItem(*arg2);
24546
24547         wxPyEndAllowThreads(__tstate);
24548         if (PyErr_Occurred()) SWIG_fail;
24549     }
24550     {
24551         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24552     }
24553     return resultobj;
24554     fail:
24555     return NULL;
24556 }
24557
24558
24559 static PyObject *_wrap_ListCtrl_SetStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
24560     PyObject *resultobj;
24561     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24562     long arg2 ;
24563     int arg3 ;
24564     wxString *arg4 = 0 ;
24565     int arg5 = (int) -1 ;
24566     long result;
24567     bool temp4 = false ;
24568     PyObject * obj0 = 0 ;
24569     PyObject * obj1 = 0 ;
24570     PyObject * obj2 = 0 ;
24571     PyObject * obj3 = 0 ;
24572     PyObject * obj4 = 0 ;
24573     char *kwnames[] = {
24574         (char *) "self",(char *) "index",(char *) "col",(char *) "label",(char *) "imageId", NULL
24575     };
24576
24577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:ListCtrl_SetStringItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
24578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24579     if (SWIG_arg_fail(1)) SWIG_fail;
24580     {
24581         arg2 = (long)(SWIG_As_long(obj1));
24582         if (SWIG_arg_fail(2)) SWIG_fail;
24583     }
24584     {
24585         arg3 = (int)(SWIG_As_int(obj2));
24586         if (SWIG_arg_fail(3)) SWIG_fail;
24587     }
24588     {
24589         arg4 = wxString_in_helper(obj3);
24590         if (arg4 == NULL) SWIG_fail;
24591         temp4 = true;
24592     }
24593     if (obj4) {
24594         {
24595             arg5 = (int)(SWIG_As_int(obj4));
24596             if (SWIG_arg_fail(5)) SWIG_fail;
24597         }
24598     }
24599     {
24600         PyThreadState* __tstate = wxPyBeginAllowThreads();
24601         result = (long)(arg1)->SetItem(arg2,arg3,(wxString const &)*arg4,arg5);
24602
24603         wxPyEndAllowThreads(__tstate);
24604         if (PyErr_Occurred()) SWIG_fail;
24605     }
24606     {
24607         resultobj = SWIG_From_long((long)(result));
24608     }
24609     {
24610         if (temp4)
24611         delete arg4;
24612     }
24613     return resultobj;
24614     fail:
24615     {
24616         if (temp4)
24617         delete arg4;
24618     }
24619     return NULL;
24620 }
24621
24622
24623 static PyObject *_wrap_ListCtrl_GetItemState(PyObject *, PyObject *args, PyObject *kwargs) {
24624     PyObject *resultobj;
24625     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24626     long arg2 ;
24627     long arg3 ;
24628     int result;
24629     PyObject * obj0 = 0 ;
24630     PyObject * obj1 = 0 ;
24631     PyObject * obj2 = 0 ;
24632     char *kwnames[] = {
24633         (char *) "self",(char *) "item",(char *) "stateMask", NULL
24634     };
24635
24636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_GetItemState",kwnames,&obj0,&obj1,&obj2)) goto fail;
24637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24638     if (SWIG_arg_fail(1)) SWIG_fail;
24639     {
24640         arg2 = (long)(SWIG_As_long(obj1));
24641         if (SWIG_arg_fail(2)) SWIG_fail;
24642     }
24643     {
24644         arg3 = (long)(SWIG_As_long(obj2));
24645         if (SWIG_arg_fail(3)) SWIG_fail;
24646     }
24647     {
24648         PyThreadState* __tstate = wxPyBeginAllowThreads();
24649         result = (int)((wxPyListCtrl const *)arg1)->GetItemState(arg2,arg3);
24650
24651         wxPyEndAllowThreads(__tstate);
24652         if (PyErr_Occurred()) SWIG_fail;
24653     }
24654     {
24655         resultobj = SWIG_From_int((int)(result));
24656     }
24657     return resultobj;
24658     fail:
24659     return NULL;
24660 }
24661
24662
24663 static PyObject *_wrap_ListCtrl_SetItemState(PyObject *, PyObject *args, PyObject *kwargs) {
24664     PyObject *resultobj;
24665     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24666     long arg2 ;
24667     long arg3 ;
24668     long arg4 ;
24669     bool result;
24670     PyObject * obj0 = 0 ;
24671     PyObject * obj1 = 0 ;
24672     PyObject * obj2 = 0 ;
24673     PyObject * obj3 = 0 ;
24674     char *kwnames[] = {
24675         (char *) "self",(char *) "item",(char *) "state",(char *) "stateMask", NULL
24676     };
24677
24678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_SetItemState",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24679     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24680     if (SWIG_arg_fail(1)) SWIG_fail;
24681     {
24682         arg2 = (long)(SWIG_As_long(obj1));
24683         if (SWIG_arg_fail(2)) SWIG_fail;
24684     }
24685     {
24686         arg3 = (long)(SWIG_As_long(obj2));
24687         if (SWIG_arg_fail(3)) SWIG_fail;
24688     }
24689     {
24690         arg4 = (long)(SWIG_As_long(obj3));
24691         if (SWIG_arg_fail(4)) SWIG_fail;
24692     }
24693     {
24694         PyThreadState* __tstate = wxPyBeginAllowThreads();
24695         result = (bool)(arg1)->SetItemState(arg2,arg3,arg4);
24696
24697         wxPyEndAllowThreads(__tstate);
24698         if (PyErr_Occurred()) SWIG_fail;
24699     }
24700     {
24701         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702     }
24703     return resultobj;
24704     fail:
24705     return NULL;
24706 }
24707
24708
24709 static PyObject *_wrap_ListCtrl_SetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
24710     PyObject *resultobj;
24711     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24712     long arg2 ;
24713     int arg3 ;
24714     int arg4 = (int) -1 ;
24715     bool result;
24716     PyObject * obj0 = 0 ;
24717     PyObject * obj1 = 0 ;
24718     PyObject * obj2 = 0 ;
24719     PyObject * obj3 = 0 ;
24720     char *kwnames[] = {
24721         (char *) "self",(char *) "item",(char *) "image",(char *) "selImage", NULL
24722     };
24723
24724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24726     if (SWIG_arg_fail(1)) SWIG_fail;
24727     {
24728         arg2 = (long)(SWIG_As_long(obj1));
24729         if (SWIG_arg_fail(2)) SWIG_fail;
24730     }
24731     {
24732         arg3 = (int)(SWIG_As_int(obj2));
24733         if (SWIG_arg_fail(3)) SWIG_fail;
24734     }
24735     if (obj3) {
24736         {
24737             arg4 = (int)(SWIG_As_int(obj3));
24738             if (SWIG_arg_fail(4)) SWIG_fail;
24739         }
24740     }
24741     {
24742         PyThreadState* __tstate = wxPyBeginAllowThreads();
24743         result = (bool)(arg1)->SetItemImage(arg2,arg3,arg4);
24744
24745         wxPyEndAllowThreads(__tstate);
24746         if (PyErr_Occurred()) SWIG_fail;
24747     }
24748     {
24749         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24750     }
24751     return resultobj;
24752     fail:
24753     return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_ListCtrl_GetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
24758     PyObject *resultobj;
24759     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24760     long arg2 ;
24761     wxString result;
24762     PyObject * obj0 = 0 ;
24763     PyObject * obj1 = 0 ;
24764     char *kwnames[] = {
24765         (char *) "self",(char *) "item", NULL
24766     };
24767
24768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemText",kwnames,&obj0,&obj1)) goto fail;
24769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24770     if (SWIG_arg_fail(1)) SWIG_fail;
24771     {
24772         arg2 = (long)(SWIG_As_long(obj1));
24773         if (SWIG_arg_fail(2)) SWIG_fail;
24774     }
24775     {
24776         PyThreadState* __tstate = wxPyBeginAllowThreads();
24777         result = ((wxPyListCtrl const *)arg1)->GetItemText(arg2);
24778
24779         wxPyEndAllowThreads(__tstate);
24780         if (PyErr_Occurred()) SWIG_fail;
24781     }
24782     {
24783 #if wxUSE_UNICODE
24784         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24785 #else
24786         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24787 #endif
24788     }
24789     return resultobj;
24790     fail:
24791     return NULL;
24792 }
24793
24794
24795 static PyObject *_wrap_ListCtrl_SetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
24796     PyObject *resultobj;
24797     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24798     long arg2 ;
24799     wxString *arg3 = 0 ;
24800     bool temp3 = false ;
24801     PyObject * obj0 = 0 ;
24802     PyObject * obj1 = 0 ;
24803     PyObject * obj2 = 0 ;
24804     char *kwnames[] = {
24805         (char *) "self",(char *) "item",(char *) "str", NULL
24806     };
24807
24808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) goto fail;
24809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24810     if (SWIG_arg_fail(1)) SWIG_fail;
24811     {
24812         arg2 = (long)(SWIG_As_long(obj1));
24813         if (SWIG_arg_fail(2)) SWIG_fail;
24814     }
24815     {
24816         arg3 = wxString_in_helper(obj2);
24817         if (arg3 == NULL) SWIG_fail;
24818         temp3 = true;
24819     }
24820     {
24821         PyThreadState* __tstate = wxPyBeginAllowThreads();
24822         (arg1)->SetItemText(arg2,(wxString const &)*arg3);
24823
24824         wxPyEndAllowThreads(__tstate);
24825         if (PyErr_Occurred()) SWIG_fail;
24826     }
24827     Py_INCREF(Py_None); resultobj = Py_None;
24828     {
24829         if (temp3)
24830         delete arg3;
24831     }
24832     return resultobj;
24833     fail:
24834     {
24835         if (temp3)
24836         delete arg3;
24837     }
24838     return NULL;
24839 }
24840
24841
24842 static PyObject *_wrap_ListCtrl_GetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
24843     PyObject *resultobj;
24844     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24845     long arg2 ;
24846     long result;
24847     PyObject * obj0 = 0 ;
24848     PyObject * obj1 = 0 ;
24849     char *kwnames[] = {
24850         (char *) "self",(char *) "item", NULL
24851     };
24852
24853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemData",kwnames,&obj0,&obj1)) goto fail;
24854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24855     if (SWIG_arg_fail(1)) SWIG_fail;
24856     {
24857         arg2 = (long)(SWIG_As_long(obj1));
24858         if (SWIG_arg_fail(2)) SWIG_fail;
24859     }
24860     {
24861         PyThreadState* __tstate = wxPyBeginAllowThreads();
24862         result = (long)((wxPyListCtrl const *)arg1)->GetItemData(arg2);
24863
24864         wxPyEndAllowThreads(__tstate);
24865         if (PyErr_Occurred()) SWIG_fail;
24866     }
24867     {
24868         resultobj = SWIG_From_long((long)(result));
24869     }
24870     return resultobj;
24871     fail:
24872     return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_ListCtrl_SetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
24877     PyObject *resultobj;
24878     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24879     long arg2 ;
24880     long arg3 ;
24881     bool result;
24882     PyObject * obj0 = 0 ;
24883     PyObject * obj1 = 0 ;
24884     PyObject * obj2 = 0 ;
24885     char *kwnames[] = {
24886         (char *) "self",(char *) "item",(char *) "data", NULL
24887     };
24888
24889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
24890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24891     if (SWIG_arg_fail(1)) SWIG_fail;
24892     {
24893         arg2 = (long)(SWIG_As_long(obj1));
24894         if (SWIG_arg_fail(2)) SWIG_fail;
24895     }
24896     {
24897         arg3 = (long)(SWIG_As_long(obj2));
24898         if (SWIG_arg_fail(3)) SWIG_fail;
24899     }
24900     {
24901         PyThreadState* __tstate = wxPyBeginAllowThreads();
24902         result = (bool)(arg1)->SetItemData(arg2,arg3);
24903
24904         wxPyEndAllowThreads(__tstate);
24905         if (PyErr_Occurred()) SWIG_fail;
24906     }
24907     {
24908         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909     }
24910     return resultobj;
24911     fail:
24912     return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_ListCtrl_GetItemPosition(PyObject *, PyObject *args, PyObject *kwargs) {
24917     PyObject *resultobj;
24918     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24919     long arg2 ;
24920     wxPoint result;
24921     PyObject * obj0 = 0 ;
24922     PyObject * obj1 = 0 ;
24923     char *kwnames[] = {
24924         (char *) "self",(char *) "item", NULL
24925     };
24926
24927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemPosition",kwnames,&obj0,&obj1)) goto fail;
24928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24929     if (SWIG_arg_fail(1)) SWIG_fail;
24930     {
24931         arg2 = (long)(SWIG_As_long(obj1));
24932         if (SWIG_arg_fail(2)) SWIG_fail;
24933     }
24934     {
24935         PyThreadState* __tstate = wxPyBeginAllowThreads();
24936         result = wxPyListCtrl_GetItemPosition(arg1,arg2);
24937
24938         wxPyEndAllowThreads(__tstate);
24939         if (PyErr_Occurred()) SWIG_fail;
24940     }
24941     {
24942         wxPoint * resultptr;
24943         resultptr = new wxPoint((wxPoint &)(result));
24944         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
24945     }
24946     return resultobj;
24947     fail:
24948     return NULL;
24949 }
24950
24951
24952 static PyObject *_wrap_ListCtrl_GetItemRect(PyObject *, PyObject *args, PyObject *kwargs) {
24953     PyObject *resultobj;
24954     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24955     long arg2 ;
24956     int arg3 = (int) wxLIST_RECT_BOUNDS ;
24957     wxRect result;
24958     PyObject * obj0 = 0 ;
24959     PyObject * obj1 = 0 ;
24960     PyObject * obj2 = 0 ;
24961     char *kwnames[] = {
24962         (char *) "self",(char *) "item",(char *) "code", NULL
24963     };
24964
24965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItemRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
24966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24967     if (SWIG_arg_fail(1)) SWIG_fail;
24968     {
24969         arg2 = (long)(SWIG_As_long(obj1));
24970         if (SWIG_arg_fail(2)) SWIG_fail;
24971     }
24972     if (obj2) {
24973         {
24974             arg3 = (int)(SWIG_As_int(obj2));
24975             if (SWIG_arg_fail(3)) SWIG_fail;
24976         }
24977     }
24978     {
24979         PyThreadState* __tstate = wxPyBeginAllowThreads();
24980         result = wxPyListCtrl_GetItemRect(arg1,arg2,arg3);
24981
24982         wxPyEndAllowThreads(__tstate);
24983         if (PyErr_Occurred()) SWIG_fail;
24984     }
24985     {
24986         wxRect * resultptr;
24987         resultptr = new wxRect((wxRect &)(result));
24988         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
24989     }
24990     return resultobj;
24991     fail:
24992     return NULL;
24993 }
24994
24995
24996 static PyObject *_wrap_ListCtrl_SetItemPosition(PyObject *, PyObject *args, PyObject *kwargs) {
24997     PyObject *resultobj;
24998     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24999     long arg2 ;
25000     wxPoint *arg3 = 0 ;
25001     bool result;
25002     wxPoint temp3 ;
25003     PyObject * obj0 = 0 ;
25004     PyObject * obj1 = 0 ;
25005     PyObject * obj2 = 0 ;
25006     char *kwnames[] = {
25007         (char *) "self",(char *) "item",(char *) "pos", NULL
25008     };
25009
25010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
25011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25012     if (SWIG_arg_fail(1)) SWIG_fail;
25013     {
25014         arg2 = (long)(SWIG_As_long(obj1));
25015         if (SWIG_arg_fail(2)) SWIG_fail;
25016     }
25017     {
25018         arg3 = &temp3;
25019         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25020     }
25021     {
25022         PyThreadState* __tstate = wxPyBeginAllowThreads();
25023         result = (bool)(arg1)->SetItemPosition(arg2,(wxPoint const &)*arg3);
25024
25025         wxPyEndAllowThreads(__tstate);
25026         if (PyErr_Occurred()) SWIG_fail;
25027     }
25028     {
25029         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25030     }
25031     return resultobj;
25032     fail:
25033     return NULL;
25034 }
25035
25036
25037 static PyObject *_wrap_ListCtrl_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
25038     PyObject *resultobj;
25039     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25040     int result;
25041     PyObject * obj0 = 0 ;
25042     char *kwnames[] = {
25043         (char *) "self", NULL
25044     };
25045
25046     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetItemCount",kwnames,&obj0)) goto fail;
25047     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25048     if (SWIG_arg_fail(1)) SWIG_fail;
25049     {
25050         PyThreadState* __tstate = wxPyBeginAllowThreads();
25051         result = (int)((wxPyListCtrl const *)arg1)->GetItemCount();
25052
25053         wxPyEndAllowThreads(__tstate);
25054         if (PyErr_Occurred()) SWIG_fail;
25055     }
25056     {
25057         resultobj = SWIG_From_int((int)(result));
25058     }
25059     return resultobj;
25060     fail:
25061     return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_ListCtrl_GetColumnCount(PyObject *, PyObject *args, PyObject *kwargs) {
25066     PyObject *resultobj;
25067     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25068     int result;
25069     PyObject * obj0 = 0 ;
25070     char *kwnames[] = {
25071         (char *) "self", NULL
25072     };
25073
25074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetColumnCount",kwnames,&obj0)) goto fail;
25075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25076     if (SWIG_arg_fail(1)) SWIG_fail;
25077     {
25078         PyThreadState* __tstate = wxPyBeginAllowThreads();
25079         result = (int)((wxPyListCtrl const *)arg1)->GetColumnCount();
25080
25081         wxPyEndAllowThreads(__tstate);
25082         if (PyErr_Occurred()) SWIG_fail;
25083     }
25084     {
25085         resultobj = SWIG_From_int((int)(result));
25086     }
25087     return resultobj;
25088     fail:
25089     return NULL;
25090 }
25091
25092
25093 static PyObject *_wrap_ListCtrl_GetItemSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
25094     PyObject *resultobj;
25095     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25096     wxSize result;
25097     PyObject * obj0 = 0 ;
25098     char *kwnames[] = {
25099         (char *) "self", NULL
25100     };
25101
25102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetItemSpacing",kwnames,&obj0)) goto fail;
25103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25104     if (SWIG_arg_fail(1)) SWIG_fail;
25105     {
25106         PyThreadState* __tstate = wxPyBeginAllowThreads();
25107         result = ((wxPyListCtrl const *)arg1)->GetItemSpacing();
25108
25109         wxPyEndAllowThreads(__tstate);
25110         if (PyErr_Occurred()) SWIG_fail;
25111     }
25112     {
25113         wxSize * resultptr;
25114         resultptr = new wxSize((wxSize &)(result));
25115         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25116     }
25117     return resultobj;
25118     fail:
25119     return NULL;
25120 }
25121
25122
25123 static PyObject *_wrap_ListCtrl_GetSelectedItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
25124     PyObject *resultobj;
25125     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25126     int result;
25127     PyObject * obj0 = 0 ;
25128     char *kwnames[] = {
25129         (char *) "self", NULL
25130     };
25131
25132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetSelectedItemCount",kwnames,&obj0)) goto fail;
25133     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25134     if (SWIG_arg_fail(1)) SWIG_fail;
25135     {
25136         PyThreadState* __tstate = wxPyBeginAllowThreads();
25137         result = (int)((wxPyListCtrl const *)arg1)->GetSelectedItemCount();
25138
25139         wxPyEndAllowThreads(__tstate);
25140         if (PyErr_Occurred()) SWIG_fail;
25141     }
25142     {
25143         resultobj = SWIG_From_int((int)(result));
25144     }
25145     return resultobj;
25146     fail:
25147     return NULL;
25148 }
25149
25150
25151 static PyObject *_wrap_ListCtrl_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
25152     PyObject *resultobj;
25153     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25154     wxColour result;
25155     PyObject * obj0 = 0 ;
25156     char *kwnames[] = {
25157         (char *) "self", NULL
25158     };
25159
25160     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetTextColour",kwnames,&obj0)) goto fail;
25161     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25162     if (SWIG_arg_fail(1)) SWIG_fail;
25163     {
25164         PyThreadState* __tstate = wxPyBeginAllowThreads();
25165         result = ((wxPyListCtrl const *)arg1)->GetTextColour();
25166
25167         wxPyEndAllowThreads(__tstate);
25168         if (PyErr_Occurred()) SWIG_fail;
25169     }
25170     {
25171         wxColour * resultptr;
25172         resultptr = new wxColour((wxColour &)(result));
25173         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
25174     }
25175     return resultobj;
25176     fail:
25177     return NULL;
25178 }
25179
25180
25181 static PyObject *_wrap_ListCtrl_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
25182     PyObject *resultobj;
25183     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25184     wxColour *arg2 = 0 ;
25185     wxColour temp2 ;
25186     PyObject * obj0 = 0 ;
25187     PyObject * obj1 = 0 ;
25188     char *kwnames[] = {
25189         (char *) "self",(char *) "col", NULL
25190     };
25191
25192     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
25193     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25194     if (SWIG_arg_fail(1)) SWIG_fail;
25195     {
25196         arg2 = &temp2;
25197         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25198     }
25199     {
25200         PyThreadState* __tstate = wxPyBeginAllowThreads();
25201         (arg1)->SetTextColour((wxColour const &)*arg2);
25202
25203         wxPyEndAllowThreads(__tstate);
25204         if (PyErr_Occurred()) SWIG_fail;
25205     }
25206     Py_INCREF(Py_None); resultobj = Py_None;
25207     return resultobj;
25208     fail:
25209     return NULL;
25210 }
25211
25212
25213 static PyObject *_wrap_ListCtrl_GetTopItem(PyObject *, PyObject *args, PyObject *kwargs) {
25214     PyObject *resultobj;
25215     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25216     long result;
25217     PyObject * obj0 = 0 ;
25218     char *kwnames[] = {
25219         (char *) "self", NULL
25220     };
25221
25222     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetTopItem",kwnames,&obj0)) goto fail;
25223     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25224     if (SWIG_arg_fail(1)) SWIG_fail;
25225     {
25226         PyThreadState* __tstate = wxPyBeginAllowThreads();
25227         result = (long)((wxPyListCtrl const *)arg1)->GetTopItem();
25228
25229         wxPyEndAllowThreads(__tstate);
25230         if (PyErr_Occurred()) SWIG_fail;
25231     }
25232     {
25233         resultobj = SWIG_From_long((long)(result));
25234     }
25235     return resultobj;
25236     fail:
25237     return NULL;
25238 }
25239
25240
25241 static PyObject *_wrap_ListCtrl_SetSingleStyle(PyObject *, PyObject *args, PyObject *kwargs) {
25242     PyObject *resultobj;
25243     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25244     long arg2 ;
25245     bool arg3 = (bool) true ;
25246     PyObject * obj0 = 0 ;
25247     PyObject * obj1 = 0 ;
25248     PyObject * obj2 = 0 ;
25249     char *kwnames[] = {
25250         (char *) "self",(char *) "style",(char *) "add", NULL
25251     };
25252
25253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_SetSingleStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
25254     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25255     if (SWIG_arg_fail(1)) SWIG_fail;
25256     {
25257         arg2 = (long)(SWIG_As_long(obj1));
25258         if (SWIG_arg_fail(2)) SWIG_fail;
25259     }
25260     if (obj2) {
25261         {
25262             arg3 = (bool)(SWIG_As_bool(obj2));
25263             if (SWIG_arg_fail(3)) SWIG_fail;
25264         }
25265     }
25266     {
25267         PyThreadState* __tstate = wxPyBeginAllowThreads();
25268         (arg1)->SetSingleStyle(arg2,arg3);
25269
25270         wxPyEndAllowThreads(__tstate);
25271         if (PyErr_Occurred()) SWIG_fail;
25272     }
25273     Py_INCREF(Py_None); resultobj = Py_None;
25274     return resultobj;
25275     fail:
25276     return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_ListCtrl_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
25281     PyObject *resultobj;
25282     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25283     long arg2 ;
25284     PyObject * obj0 = 0 ;
25285     PyObject * obj1 = 0 ;
25286     char *kwnames[] = {
25287         (char *) "self",(char *) "style", NULL
25288     };
25289
25290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
25291     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25292     if (SWIG_arg_fail(1)) SWIG_fail;
25293     {
25294         arg2 = (long)(SWIG_As_long(obj1));
25295         if (SWIG_arg_fail(2)) SWIG_fail;
25296     }
25297     {
25298         PyThreadState* __tstate = wxPyBeginAllowThreads();
25299         (arg1)->SetWindowStyleFlag(arg2);
25300
25301         wxPyEndAllowThreads(__tstate);
25302         if (PyErr_Occurred()) SWIG_fail;
25303     }
25304     Py_INCREF(Py_None); resultobj = Py_None;
25305     return resultobj;
25306     fail:
25307     return NULL;
25308 }
25309
25310
25311 static PyObject *_wrap_ListCtrl_GetNextItem(PyObject *, PyObject *args, PyObject *kwargs) {
25312     PyObject *resultobj;
25313     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25314     long arg2 ;
25315     int arg3 = (int) wxLIST_NEXT_ALL ;
25316     int arg4 = (int) wxLIST_STATE_DONTCARE ;
25317     long result;
25318     PyObject * obj0 = 0 ;
25319     PyObject * obj1 = 0 ;
25320     PyObject * obj2 = 0 ;
25321     PyObject * obj3 = 0 ;
25322     char *kwnames[] = {
25323         (char *) "self",(char *) "item",(char *) "geometry",(char *) "state", NULL
25324     };
25325
25326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:ListCtrl_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25327     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25328     if (SWIG_arg_fail(1)) SWIG_fail;
25329     {
25330         arg2 = (long)(SWIG_As_long(obj1));
25331         if (SWIG_arg_fail(2)) SWIG_fail;
25332     }
25333     if (obj2) {
25334         {
25335             arg3 = (int)(SWIG_As_int(obj2));
25336             if (SWIG_arg_fail(3)) SWIG_fail;
25337         }
25338     }
25339     if (obj3) {
25340         {
25341             arg4 = (int)(SWIG_As_int(obj3));
25342             if (SWIG_arg_fail(4)) SWIG_fail;
25343         }
25344     }
25345     {
25346         PyThreadState* __tstate = wxPyBeginAllowThreads();
25347         result = (long)((wxPyListCtrl const *)arg1)->GetNextItem(arg2,arg3,arg4);
25348
25349         wxPyEndAllowThreads(__tstate);
25350         if (PyErr_Occurred()) SWIG_fail;
25351     }
25352     {
25353         resultobj = SWIG_From_long((long)(result));
25354     }
25355     return resultobj;
25356     fail:
25357     return NULL;
25358 }
25359
25360
25361 static PyObject *_wrap_ListCtrl_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25362     PyObject *resultobj;
25363     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25364     int arg2 ;
25365     wxImageList *result;
25366     PyObject * obj0 = 0 ;
25367     PyObject * obj1 = 0 ;
25368     char *kwnames[] = {
25369         (char *) "self",(char *) "which", NULL
25370     };
25371
25372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetImageList",kwnames,&obj0,&obj1)) goto fail;
25373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25374     if (SWIG_arg_fail(1)) SWIG_fail;
25375     {
25376         arg2 = (int)(SWIG_As_int(obj1));
25377         if (SWIG_arg_fail(2)) SWIG_fail;
25378     }
25379     {
25380         PyThreadState* __tstate = wxPyBeginAllowThreads();
25381         result = (wxImageList *)((wxPyListCtrl const *)arg1)->GetImageList(arg2);
25382
25383         wxPyEndAllowThreads(__tstate);
25384         if (PyErr_Occurred()) SWIG_fail;
25385     }
25386     {
25387         resultobj = wxPyMake_wxObject(result, 0);
25388     }
25389     return resultobj;
25390     fail:
25391     return NULL;
25392 }
25393
25394
25395 static PyObject *_wrap_ListCtrl_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25396     PyObject *resultobj;
25397     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25398     wxImageList *arg2 = (wxImageList *) 0 ;
25399     int arg3 ;
25400     PyObject * obj0 = 0 ;
25401     PyObject * obj1 = 0 ;
25402     PyObject * obj2 = 0 ;
25403     char *kwnames[] = {
25404         (char *) "self",(char *) "imageList",(char *) "which", NULL
25405     };
25406
25407     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetImageList",kwnames,&obj0,&obj1,&obj2)) goto fail;
25408     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25409     if (SWIG_arg_fail(1)) SWIG_fail;
25410     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
25411     if (SWIG_arg_fail(2)) SWIG_fail;
25412     {
25413         arg3 = (int)(SWIG_As_int(obj2));
25414         if (SWIG_arg_fail(3)) SWIG_fail;
25415     }
25416     {
25417         PyThreadState* __tstate = wxPyBeginAllowThreads();
25418         (arg1)->SetImageList(arg2,arg3);
25419
25420         wxPyEndAllowThreads(__tstate);
25421         if (PyErr_Occurred()) SWIG_fail;
25422     }
25423     Py_INCREF(Py_None); resultobj = Py_None;
25424     return resultobj;
25425     fail:
25426     return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_ListCtrl_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25431     PyObject *resultobj;
25432     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25433     wxImageList *arg2 = (wxImageList *) 0 ;
25434     int arg3 ;
25435     PyObject * obj0 = 0 ;
25436     PyObject * obj1 = 0 ;
25437     PyObject * obj2 = 0 ;
25438     char *kwnames[] = {
25439         (char *) "self",(char *) "imageList",(char *) "which", NULL
25440     };
25441
25442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_AssignImageList",kwnames,&obj0,&obj1,&obj2)) goto fail;
25443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25444     if (SWIG_arg_fail(1)) SWIG_fail;
25445     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25446     if (SWIG_arg_fail(2)) SWIG_fail;
25447     {
25448         arg3 = (int)(SWIG_As_int(obj2));
25449         if (SWIG_arg_fail(3)) SWIG_fail;
25450     }
25451     {
25452         PyThreadState* __tstate = wxPyBeginAllowThreads();
25453         (arg1)->AssignImageList(arg2,arg3);
25454
25455         wxPyEndAllowThreads(__tstate);
25456         if (PyErr_Occurred()) SWIG_fail;
25457     }
25458     Py_INCREF(Py_None); resultobj = Py_None;
25459     return resultobj;
25460     fail:
25461     return NULL;
25462 }
25463
25464
25465 static PyObject *_wrap_ListCtrl_InReportView(PyObject *, PyObject *args, PyObject *kwargs) {
25466     PyObject *resultobj;
25467     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25468     bool result;
25469     PyObject * obj0 = 0 ;
25470     char *kwnames[] = {
25471         (char *) "self", NULL
25472     };
25473
25474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_InReportView",kwnames,&obj0)) goto fail;
25475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25476     if (SWIG_arg_fail(1)) SWIG_fail;
25477     {
25478         PyThreadState* __tstate = wxPyBeginAllowThreads();
25479         result = (bool)((wxPyListCtrl const *)arg1)->InReportView();
25480
25481         wxPyEndAllowThreads(__tstate);
25482         if (PyErr_Occurred()) SWIG_fail;
25483     }
25484     {
25485         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25486     }
25487     return resultobj;
25488     fail:
25489     return NULL;
25490 }
25491
25492
25493 static PyObject *_wrap_ListCtrl_IsVirtual(PyObject *, PyObject *args, PyObject *kwargs) {
25494     PyObject *resultobj;
25495     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25496     bool result;
25497     PyObject * obj0 = 0 ;
25498     char *kwnames[] = {
25499         (char *) "self", NULL
25500     };
25501
25502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_IsVirtual",kwnames,&obj0)) goto fail;
25503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25504     if (SWIG_arg_fail(1)) SWIG_fail;
25505     {
25506         PyThreadState* __tstate = wxPyBeginAllowThreads();
25507         result = (bool)((wxPyListCtrl const *)arg1)->IsVirtual();
25508
25509         wxPyEndAllowThreads(__tstate);
25510         if (PyErr_Occurred()) SWIG_fail;
25511     }
25512     {
25513         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25514     }
25515     return resultobj;
25516     fail:
25517     return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_ListCtrl_RefreshItem(PyObject *, PyObject *args, PyObject *kwargs) {
25522     PyObject *resultobj;
25523     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25524     long arg2 ;
25525     PyObject * obj0 = 0 ;
25526     PyObject * obj1 = 0 ;
25527     char *kwnames[] = {
25528         (char *) "self",(char *) "item", NULL
25529     };
25530
25531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_RefreshItem",kwnames,&obj0,&obj1)) goto fail;
25532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25533     if (SWIG_arg_fail(1)) SWIG_fail;
25534     {
25535         arg2 = (long)(SWIG_As_long(obj1));
25536         if (SWIG_arg_fail(2)) SWIG_fail;
25537     }
25538     {
25539         PyThreadState* __tstate = wxPyBeginAllowThreads();
25540         (arg1)->RefreshItem(arg2);
25541
25542         wxPyEndAllowThreads(__tstate);
25543         if (PyErr_Occurred()) SWIG_fail;
25544     }
25545     Py_INCREF(Py_None); resultobj = Py_None;
25546     return resultobj;
25547     fail:
25548     return NULL;
25549 }
25550
25551
25552 static PyObject *_wrap_ListCtrl_RefreshItems(PyObject *, PyObject *args, PyObject *kwargs) {
25553     PyObject *resultobj;
25554     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25555     long arg2 ;
25556     long arg3 ;
25557     PyObject * obj0 = 0 ;
25558     PyObject * obj1 = 0 ;
25559     PyObject * obj2 = 0 ;
25560     char *kwnames[] = {
25561         (char *) "self",(char *) "itemFrom",(char *) "itemTo", NULL
25562     };
25563
25564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_RefreshItems",kwnames,&obj0,&obj1,&obj2)) goto fail;
25565     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25566     if (SWIG_arg_fail(1)) SWIG_fail;
25567     {
25568         arg2 = (long)(SWIG_As_long(obj1));
25569         if (SWIG_arg_fail(2)) SWIG_fail;
25570     }
25571     {
25572         arg3 = (long)(SWIG_As_long(obj2));
25573         if (SWIG_arg_fail(3)) SWIG_fail;
25574     }
25575     {
25576         PyThreadState* __tstate = wxPyBeginAllowThreads();
25577         (arg1)->RefreshItems(arg2,arg3);
25578
25579         wxPyEndAllowThreads(__tstate);
25580         if (PyErr_Occurred()) SWIG_fail;
25581     }
25582     Py_INCREF(Py_None); resultobj = Py_None;
25583     return resultobj;
25584     fail:
25585     return NULL;
25586 }
25587
25588
25589 static PyObject *_wrap_ListCtrl_Arrange(PyObject *, PyObject *args, PyObject *kwargs) {
25590     PyObject *resultobj;
25591     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25592     int arg2 = (int) wxLIST_ALIGN_DEFAULT ;
25593     bool result;
25594     PyObject * obj0 = 0 ;
25595     PyObject * obj1 = 0 ;
25596     char *kwnames[] = {
25597         (char *) "self",(char *) "flag", NULL
25598     };
25599
25600     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListCtrl_Arrange",kwnames,&obj0,&obj1)) goto fail;
25601     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25602     if (SWIG_arg_fail(1)) SWIG_fail;
25603     if (obj1) {
25604         {
25605             arg2 = (int)(SWIG_As_int(obj1));
25606             if (SWIG_arg_fail(2)) SWIG_fail;
25607         }
25608     }
25609     {
25610         PyThreadState* __tstate = wxPyBeginAllowThreads();
25611         result = (bool)(arg1)->Arrange(arg2);
25612
25613         wxPyEndAllowThreads(__tstate);
25614         if (PyErr_Occurred()) SWIG_fail;
25615     }
25616     {
25617         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25618     }
25619     return resultobj;
25620     fail:
25621     return NULL;
25622 }
25623
25624
25625 static PyObject *_wrap_ListCtrl_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
25626     PyObject *resultobj;
25627     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25628     long arg2 ;
25629     bool result;
25630     PyObject * obj0 = 0 ;
25631     PyObject * obj1 = 0 ;
25632     char *kwnames[] = {
25633         (char *) "self",(char *) "item", NULL
25634     };
25635
25636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
25637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25638     if (SWIG_arg_fail(1)) SWIG_fail;
25639     {
25640         arg2 = (long)(SWIG_As_long(obj1));
25641         if (SWIG_arg_fail(2)) SWIG_fail;
25642     }
25643     {
25644         PyThreadState* __tstate = wxPyBeginAllowThreads();
25645         result = (bool)(arg1)->DeleteItem(arg2);
25646
25647         wxPyEndAllowThreads(__tstate);
25648         if (PyErr_Occurred()) SWIG_fail;
25649     }
25650     {
25651         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652     }
25653     return resultobj;
25654     fail:
25655     return NULL;
25656 }
25657
25658
25659 static PyObject *_wrap_ListCtrl_DeleteAllItems(PyObject *, PyObject *args, PyObject *kwargs) {
25660     PyObject *resultobj;
25661     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25662     bool result;
25663     PyObject * obj0 = 0 ;
25664     char *kwnames[] = {
25665         (char *) "self", NULL
25666     };
25667
25668     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_DeleteAllItems",kwnames,&obj0)) goto fail;
25669     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25670     if (SWIG_arg_fail(1)) SWIG_fail;
25671     {
25672         PyThreadState* __tstate = wxPyBeginAllowThreads();
25673         result = (bool)(arg1)->DeleteAllItems();
25674
25675         wxPyEndAllowThreads(__tstate);
25676         if (PyErr_Occurred()) SWIG_fail;
25677     }
25678     {
25679         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25680     }
25681     return resultobj;
25682     fail:
25683     return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_ListCtrl_DeleteColumn(PyObject *, PyObject *args, PyObject *kwargs) {
25688     PyObject *resultobj;
25689     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25690     int arg2 ;
25691     bool result;
25692     PyObject * obj0 = 0 ;
25693     PyObject * obj1 = 0 ;
25694     char *kwnames[] = {
25695         (char *) "self",(char *) "col", NULL
25696     };
25697
25698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteColumn",kwnames,&obj0,&obj1)) goto fail;
25699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25700     if (SWIG_arg_fail(1)) SWIG_fail;
25701     {
25702         arg2 = (int)(SWIG_As_int(obj1));
25703         if (SWIG_arg_fail(2)) SWIG_fail;
25704     }
25705     {
25706         PyThreadState* __tstate = wxPyBeginAllowThreads();
25707         result = (bool)(arg1)->DeleteColumn(arg2);
25708
25709         wxPyEndAllowThreads(__tstate);
25710         if (PyErr_Occurred()) SWIG_fail;
25711     }
25712     {
25713         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25714     }
25715     return resultobj;
25716     fail:
25717     return NULL;
25718 }
25719
25720
25721 static PyObject *_wrap_ListCtrl_DeleteAllColumns(PyObject *, PyObject *args, PyObject *kwargs) {
25722     PyObject *resultobj;
25723     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25724     bool result;
25725     PyObject * obj0 = 0 ;
25726     char *kwnames[] = {
25727         (char *) "self", NULL
25728     };
25729
25730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_DeleteAllColumns",kwnames,&obj0)) goto fail;
25731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25732     if (SWIG_arg_fail(1)) SWIG_fail;
25733     {
25734         PyThreadState* __tstate = wxPyBeginAllowThreads();
25735         result = (bool)(arg1)->DeleteAllColumns();
25736
25737         wxPyEndAllowThreads(__tstate);
25738         if (PyErr_Occurred()) SWIG_fail;
25739     }
25740     {
25741         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25742     }
25743     return resultobj;
25744     fail:
25745     return NULL;
25746 }
25747
25748
25749 static PyObject *_wrap_ListCtrl_ClearAll(PyObject *, PyObject *args, PyObject *kwargs) {
25750     PyObject *resultobj;
25751     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25752     PyObject * obj0 = 0 ;
25753     char *kwnames[] = {
25754         (char *) "self", NULL
25755     };
25756
25757     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_ClearAll",kwnames,&obj0)) goto fail;
25758     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25759     if (SWIG_arg_fail(1)) SWIG_fail;
25760     {
25761         PyThreadState* __tstate = wxPyBeginAllowThreads();
25762         (arg1)->ClearAll();
25763
25764         wxPyEndAllowThreads(__tstate);
25765         if (PyErr_Occurred()) SWIG_fail;
25766     }
25767     Py_INCREF(Py_None); resultobj = Py_None;
25768     return resultobj;
25769     fail:
25770     return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_ListCtrl_EditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25775     PyObject *resultobj;
25776     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25777     long arg2 ;
25778     wxTextCtrl *result;
25779     PyObject * obj0 = 0 ;
25780     PyObject * obj1 = 0 ;
25781     char *kwnames[] = {
25782         (char *) "self",(char *) "item", NULL
25783     };
25784
25785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EditLabel",kwnames,&obj0,&obj1)) goto fail;
25786     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25787     if (SWIG_arg_fail(1)) SWIG_fail;
25788     {
25789         arg2 = (long)(SWIG_As_long(obj1));
25790         if (SWIG_arg_fail(2)) SWIG_fail;
25791     }
25792     {
25793         PyThreadState* __tstate = wxPyBeginAllowThreads();
25794         result = (wxTextCtrl *)(arg1)->EditLabel(arg2);
25795
25796         wxPyEndAllowThreads(__tstate);
25797         if (PyErr_Occurred()) SWIG_fail;
25798     }
25799     {
25800         resultobj = wxPyMake_wxObject(result, 0);
25801     }
25802     return resultobj;
25803     fail:
25804     return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_ListCtrl_EndEditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25809     PyObject *resultobj;
25810     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25811     bool arg2 ;
25812     bool result;
25813     PyObject * obj0 = 0 ;
25814     PyObject * obj1 = 0 ;
25815     char *kwnames[] = {
25816         (char *) "self",(char *) "cancel", NULL
25817     };
25818
25819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EndEditLabel",kwnames,&obj0,&obj1)) goto fail;
25820     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25821     if (SWIG_arg_fail(1)) SWIG_fail;
25822     {
25823         arg2 = (bool)(SWIG_As_bool(obj1));
25824         if (SWIG_arg_fail(2)) SWIG_fail;
25825     }
25826     {
25827         PyThreadState* __tstate = wxPyBeginAllowThreads();
25828         result = (bool)(arg1)->EndEditLabel(arg2);
25829
25830         wxPyEndAllowThreads(__tstate);
25831         if (PyErr_Occurred()) SWIG_fail;
25832     }
25833     {
25834         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25835     }
25836     return resultobj;
25837     fail:
25838     return NULL;
25839 }
25840
25841
25842 static PyObject *_wrap_ListCtrl_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
25843     PyObject *resultobj;
25844     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25845     long arg2 ;
25846     bool result;
25847     PyObject * obj0 = 0 ;
25848     PyObject * obj1 = 0 ;
25849     char *kwnames[] = {
25850         (char *) "self",(char *) "item", NULL
25851     };
25852
25853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
25854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25855     if (SWIG_arg_fail(1)) SWIG_fail;
25856     {
25857         arg2 = (long)(SWIG_As_long(obj1));
25858         if (SWIG_arg_fail(2)) SWIG_fail;
25859     }
25860     {
25861         PyThreadState* __tstate = wxPyBeginAllowThreads();
25862         result = (bool)(arg1)->EnsureVisible(arg2);
25863
25864         wxPyEndAllowThreads(__tstate);
25865         if (PyErr_Occurred()) SWIG_fail;
25866     }
25867     {
25868         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25869     }
25870     return resultobj;
25871     fail:
25872     return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_ListCtrl_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
25877     PyObject *resultobj;
25878     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25879     long arg2 ;
25880     wxString *arg3 = 0 ;
25881     bool arg4 = (bool) false ;
25882     long result;
25883     bool temp3 = false ;
25884     PyObject * obj0 = 0 ;
25885     PyObject * obj1 = 0 ;
25886     PyObject * obj2 = 0 ;
25887     PyObject * obj3 = 0 ;
25888     char *kwnames[] = {
25889         (char *) "self",(char *) "start",(char *) "str",(char *) "partial", NULL
25890     };
25891
25892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_FindItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25894     if (SWIG_arg_fail(1)) SWIG_fail;
25895     {
25896         arg2 = (long)(SWIG_As_long(obj1));
25897         if (SWIG_arg_fail(2)) SWIG_fail;
25898     }
25899     {
25900         arg3 = wxString_in_helper(obj2);
25901         if (arg3 == NULL) SWIG_fail;
25902         temp3 = true;
25903     }
25904     if (obj3) {
25905         {
25906             arg4 = (bool)(SWIG_As_bool(obj3));
25907             if (SWIG_arg_fail(4)) SWIG_fail;
25908         }
25909     }
25910     {
25911         PyThreadState* __tstate = wxPyBeginAllowThreads();
25912         result = (long)(arg1)->FindItem(arg2,(wxString const &)*arg3,arg4);
25913
25914         wxPyEndAllowThreads(__tstate);
25915         if (PyErr_Occurred()) SWIG_fail;
25916     }
25917     {
25918         resultobj = SWIG_From_long((long)(result));
25919     }
25920     {
25921         if (temp3)
25922         delete arg3;
25923     }
25924     return resultobj;
25925     fail:
25926     {
25927         if (temp3)
25928         delete arg3;
25929     }
25930     return NULL;
25931 }
25932
25933
25934 static PyObject *_wrap_ListCtrl_FindItemData(PyObject *, PyObject *args, PyObject *kwargs) {
25935     PyObject *resultobj;
25936     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25937     long arg2 ;
25938     long arg3 ;
25939     long result;
25940     PyObject * obj0 = 0 ;
25941     PyObject * obj1 = 0 ;
25942     PyObject * obj2 = 0 ;
25943     char *kwnames[] = {
25944         (char *) "self",(char *) "start",(char *) "data", NULL
25945     };
25946
25947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_FindItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
25948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25949     if (SWIG_arg_fail(1)) SWIG_fail;
25950     {
25951         arg2 = (long)(SWIG_As_long(obj1));
25952         if (SWIG_arg_fail(2)) SWIG_fail;
25953     }
25954     {
25955         arg3 = (long)(SWIG_As_long(obj2));
25956         if (SWIG_arg_fail(3)) SWIG_fail;
25957     }
25958     {
25959         PyThreadState* __tstate = wxPyBeginAllowThreads();
25960         result = (long)(arg1)->FindItem(arg2,arg3);
25961
25962         wxPyEndAllowThreads(__tstate);
25963         if (PyErr_Occurred()) SWIG_fail;
25964     }
25965     {
25966         resultobj = SWIG_From_long((long)(result));
25967     }
25968     return resultobj;
25969     fail:
25970     return NULL;
25971 }
25972
25973
25974 static PyObject *_wrap_ListCtrl_FindItemAtPos(PyObject *, PyObject *args, PyObject *kwargs) {
25975     PyObject *resultobj;
25976     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25977     long arg2 ;
25978     wxPoint *arg3 = 0 ;
25979     int arg4 ;
25980     long result;
25981     wxPoint temp3 ;
25982     PyObject * obj0 = 0 ;
25983     PyObject * obj1 = 0 ;
25984     PyObject * obj2 = 0 ;
25985     PyObject * obj3 = 0 ;
25986     char *kwnames[] = {
25987         (char *) "self",(char *) "start",(char *) "pt",(char *) "direction", NULL
25988     };
25989
25990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_FindItemAtPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25992     if (SWIG_arg_fail(1)) SWIG_fail;
25993     {
25994         arg2 = (long)(SWIG_As_long(obj1));
25995         if (SWIG_arg_fail(2)) SWIG_fail;
25996     }
25997     {
25998         arg3 = &temp3;
25999         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26000     }
26001     {
26002         arg4 = (int)(SWIG_As_int(obj3));
26003         if (SWIG_arg_fail(4)) SWIG_fail;
26004     }
26005     {
26006         PyThreadState* __tstate = wxPyBeginAllowThreads();
26007         result = (long)(arg1)->FindItem(arg2,(wxPoint const &)*arg3,arg4);
26008
26009         wxPyEndAllowThreads(__tstate);
26010         if (PyErr_Occurred()) SWIG_fail;
26011     }
26012     {
26013         resultobj = SWIG_From_long((long)(result));
26014     }
26015     return resultobj;
26016     fail:
26017     return NULL;
26018 }
26019
26020
26021 static PyObject *_wrap_ListCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
26022     PyObject *resultobj;
26023     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26024     wxPoint *arg2 = 0 ;
26025     int *arg3 = 0 ;
26026     long result;
26027     wxPoint temp2 ;
26028     int temp3 ;
26029     int res3 = 0 ;
26030     PyObject * obj0 = 0 ;
26031     PyObject * obj1 = 0 ;
26032     char *kwnames[] = {
26033         (char *) "self",(char *) "point", NULL
26034     };
26035
26036     arg3 = &temp3; res3 = SWIG_NEWOBJ;
26037     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
26038     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26039     if (SWIG_arg_fail(1)) SWIG_fail;
26040     {
26041         arg2 = &temp2;
26042         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26043     }
26044     {
26045         PyThreadState* __tstate = wxPyBeginAllowThreads();
26046         result = (long)(arg1)->HitTest((wxPoint const &)*arg2,*arg3);
26047
26048         wxPyEndAllowThreads(__tstate);
26049         if (PyErr_Occurred()) SWIG_fail;
26050     }
26051     {
26052         resultobj = SWIG_From_long((long)(result));
26053     }
26054     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26055     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26056     return resultobj;
26057     fail:
26058     return NULL;
26059 }
26060
26061
26062 static PyObject *_wrap_ListCtrl_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
26063     PyObject *resultobj;
26064     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26065     wxListItem *arg2 = 0 ;
26066     long result;
26067     PyObject * obj0 = 0 ;
26068     PyObject * obj1 = 0 ;
26069     char *kwnames[] = {
26070         (char *) "self",(char *) "info", NULL
26071     };
26072
26073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_InsertItem",kwnames,&obj0,&obj1)) goto fail;
26074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26075     if (SWIG_arg_fail(1)) SWIG_fail;
26076     {
26077         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
26078         if (SWIG_arg_fail(2)) SWIG_fail;
26079         if (arg2 == NULL) {
26080             SWIG_null_ref("wxListItem");
26081         }
26082         if (SWIG_arg_fail(2)) SWIG_fail;
26083     }
26084     {
26085         PyThreadState* __tstate = wxPyBeginAllowThreads();
26086         result = (long)(arg1)->InsertItem(*arg2);
26087
26088         wxPyEndAllowThreads(__tstate);
26089         if (PyErr_Occurred()) SWIG_fail;
26090     }
26091     {
26092         resultobj = SWIG_From_long((long)(result));
26093     }
26094     return resultobj;
26095     fail:
26096     return NULL;
26097 }
26098
26099
26100 static PyObject *_wrap_ListCtrl_InsertStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
26101     PyObject *resultobj;
26102     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26103     long arg2 ;
26104     wxString *arg3 = 0 ;
26105     long result;
26106     bool temp3 = false ;
26107     PyObject * obj0 = 0 ;
26108     PyObject * obj1 = 0 ;
26109     PyObject * obj2 = 0 ;
26110     char *kwnames[] = {
26111         (char *) "self",(char *) "index",(char *) "label", NULL
26112     };
26113
26114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertStringItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
26115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26116     if (SWIG_arg_fail(1)) SWIG_fail;
26117     {
26118         arg2 = (long)(SWIG_As_long(obj1));
26119         if (SWIG_arg_fail(2)) SWIG_fail;
26120     }
26121     {
26122         arg3 = wxString_in_helper(obj2);
26123         if (arg3 == NULL) SWIG_fail;
26124         temp3 = true;
26125     }
26126     {
26127         PyThreadState* __tstate = wxPyBeginAllowThreads();
26128         result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3);
26129
26130         wxPyEndAllowThreads(__tstate);
26131         if (PyErr_Occurred()) SWIG_fail;
26132     }
26133     {
26134         resultobj = SWIG_From_long((long)(result));
26135     }
26136     {
26137         if (temp3)
26138         delete arg3;
26139     }
26140     return resultobj;
26141     fail:
26142     {
26143         if (temp3)
26144         delete arg3;
26145     }
26146     return NULL;
26147 }
26148
26149
26150 static PyObject *_wrap_ListCtrl_InsertImageItem(PyObject *, PyObject *args, PyObject *kwargs) {
26151     PyObject *resultobj;
26152     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26153     long arg2 ;
26154     int arg3 ;
26155     long result;
26156     PyObject * obj0 = 0 ;
26157     PyObject * obj1 = 0 ;
26158     PyObject * obj2 = 0 ;
26159     char *kwnames[] = {
26160         (char *) "self",(char *) "index",(char *) "imageIndex", NULL
26161     };
26162
26163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertImageItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
26164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26165     if (SWIG_arg_fail(1)) SWIG_fail;
26166     {
26167         arg2 = (long)(SWIG_As_long(obj1));
26168         if (SWIG_arg_fail(2)) SWIG_fail;
26169     }
26170     {
26171         arg3 = (int)(SWIG_As_int(obj2));
26172         if (SWIG_arg_fail(3)) SWIG_fail;
26173     }
26174     {
26175         PyThreadState* __tstate = wxPyBeginAllowThreads();
26176         result = (long)(arg1)->InsertItem(arg2,arg3);
26177
26178         wxPyEndAllowThreads(__tstate);
26179         if (PyErr_Occurred()) SWIG_fail;
26180     }
26181     {
26182         resultobj = SWIG_From_long((long)(result));
26183     }
26184     return resultobj;
26185     fail:
26186     return NULL;
26187 }
26188
26189
26190 static PyObject *_wrap_ListCtrl_InsertImageStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
26191     PyObject *resultobj;
26192     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26193     long arg2 ;
26194     wxString *arg3 = 0 ;
26195     int arg4 ;
26196     long result;
26197     bool temp3 = false ;
26198     PyObject * obj0 = 0 ;
26199     PyObject * obj1 = 0 ;
26200     PyObject * obj2 = 0 ;
26201     PyObject * obj3 = 0 ;
26202     char *kwnames[] = {
26203         (char *) "self",(char *) "index",(char *) "label",(char *) "imageIndex", NULL
26204     };
26205
26206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_InsertImageStringItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26207     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26208     if (SWIG_arg_fail(1)) SWIG_fail;
26209     {
26210         arg2 = (long)(SWIG_As_long(obj1));
26211         if (SWIG_arg_fail(2)) SWIG_fail;
26212     }
26213     {
26214         arg3 = wxString_in_helper(obj2);
26215         if (arg3 == NULL) SWIG_fail;
26216         temp3 = true;
26217     }
26218     {
26219         arg4 = (int)(SWIG_As_int(obj3));
26220         if (SWIG_arg_fail(4)) SWIG_fail;
26221     }
26222     {
26223         PyThreadState* __tstate = wxPyBeginAllowThreads();
26224         result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3,arg4);
26225
26226         wxPyEndAllowThreads(__tstate);
26227         if (PyErr_Occurred()) SWIG_fail;
26228     }
26229     {
26230         resultobj = SWIG_From_long((long)(result));
26231     }
26232     {
26233         if (temp3)
26234         delete arg3;
26235     }
26236     return resultobj;
26237     fail:
26238     {
26239         if (temp3)
26240         delete arg3;
26241     }
26242     return NULL;
26243 }
26244
26245
26246 static PyObject *_wrap_ListCtrl_InsertColumnInfo(PyObject *, PyObject *args, PyObject *kwargs) {
26247     PyObject *resultobj;
26248     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26249     long arg2 ;
26250     wxListItem *arg3 = 0 ;
26251     long result;
26252     PyObject * obj0 = 0 ;
26253     PyObject * obj1 = 0 ;
26254     PyObject * obj2 = 0 ;
26255     char *kwnames[] = {
26256         (char *) "self",(char *) "col",(char *) "info", NULL
26257     };
26258
26259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertColumnInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
26260     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26261     if (SWIG_arg_fail(1)) SWIG_fail;
26262     {
26263         arg2 = (long)(SWIG_As_long(obj1));
26264         if (SWIG_arg_fail(2)) SWIG_fail;
26265     }
26266     {
26267         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
26268         if (SWIG_arg_fail(3)) SWIG_fail;
26269         if (arg3 == NULL) {
26270             SWIG_null_ref("wxListItem");
26271         }
26272         if (SWIG_arg_fail(3)) SWIG_fail;
26273     }
26274     {
26275         PyThreadState* __tstate = wxPyBeginAllowThreads();
26276         result = (long)(arg1)->InsertColumn(arg2,*arg3);
26277
26278         wxPyEndAllowThreads(__tstate);
26279         if (PyErr_Occurred()) SWIG_fail;
26280     }
26281     {
26282         resultobj = SWIG_From_long((long)(result));
26283     }
26284     return resultobj;
26285     fail:
26286     return NULL;
26287 }
26288
26289
26290 static PyObject *_wrap_ListCtrl_InsertColumn(PyObject *, PyObject *args, PyObject *kwargs) {
26291     PyObject *resultobj;
26292     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26293     long arg2 ;
26294     wxString *arg3 = 0 ;
26295     int arg4 = (int) wxLIST_FORMAT_LEFT ;
26296     int arg5 = (int) -1 ;
26297     long result;
26298     bool temp3 = false ;
26299     PyObject * obj0 = 0 ;
26300     PyObject * obj1 = 0 ;
26301     PyObject * obj2 = 0 ;
26302     PyObject * obj3 = 0 ;
26303     PyObject * obj4 = 0 ;
26304     char *kwnames[] = {
26305         (char *) "self",(char *) "col",(char *) "heading",(char *) "format",(char *) "width", NULL
26306     };
26307
26308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:ListCtrl_InsertColumn",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26310     if (SWIG_arg_fail(1)) SWIG_fail;
26311     {
26312         arg2 = (long)(SWIG_As_long(obj1));
26313         if (SWIG_arg_fail(2)) SWIG_fail;
26314     }
26315     {
26316         arg3 = wxString_in_helper(obj2);
26317         if (arg3 == NULL) SWIG_fail;
26318         temp3 = true;
26319     }
26320     if (obj3) {
26321         {
26322             arg4 = (int)(SWIG_As_int(obj3));
26323             if (SWIG_arg_fail(4)) SWIG_fail;
26324         }
26325     }
26326     if (obj4) {
26327         {
26328             arg5 = (int)(SWIG_As_int(obj4));
26329             if (SWIG_arg_fail(5)) SWIG_fail;
26330         }
26331     }
26332     {
26333         PyThreadState* __tstate = wxPyBeginAllowThreads();
26334         result = (long)(arg1)->InsertColumn(arg2,(wxString const &)*arg3,arg4,arg5);
26335
26336         wxPyEndAllowThreads(__tstate);
26337         if (PyErr_Occurred()) SWIG_fail;
26338     }
26339     {
26340         resultobj = SWIG_From_long((long)(result));
26341     }
26342     {
26343         if (temp3)
26344         delete arg3;
26345     }
26346     return resultobj;
26347     fail:
26348     {
26349         if (temp3)
26350         delete arg3;
26351     }
26352     return NULL;
26353 }
26354
26355
26356 static PyObject *_wrap_ListCtrl_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
26357     PyObject *resultobj;
26358     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26359     long arg2 ;
26360     PyObject * obj0 = 0 ;
26361     PyObject * obj1 = 0 ;
26362     char *kwnames[] = {
26363         (char *) "self",(char *) "count", NULL
26364     };
26365
26366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
26367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26368     if (SWIG_arg_fail(1)) SWIG_fail;
26369     {
26370         arg2 = (long)(SWIG_As_long(obj1));
26371         if (SWIG_arg_fail(2)) SWIG_fail;
26372     }
26373     {
26374         PyThreadState* __tstate = wxPyBeginAllowThreads();
26375         (arg1)->SetItemCount(arg2);
26376
26377         wxPyEndAllowThreads(__tstate);
26378         if (PyErr_Occurred()) SWIG_fail;
26379     }
26380     Py_INCREF(Py_None); resultobj = Py_None;
26381     return resultobj;
26382     fail:
26383     return NULL;
26384 }
26385
26386
26387 static PyObject *_wrap_ListCtrl_ScrollList(PyObject *, PyObject *args, PyObject *kwargs) {
26388     PyObject *resultobj;
26389     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26390     int arg2 ;
26391     int arg3 ;
26392     bool result;
26393     PyObject * obj0 = 0 ;
26394     PyObject * obj1 = 0 ;
26395     PyObject * obj2 = 0 ;
26396     char *kwnames[] = {
26397         (char *) "self",(char *) "dx",(char *) "dy", NULL
26398     };
26399
26400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_ScrollList",kwnames,&obj0,&obj1,&obj2)) goto fail;
26401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26402     if (SWIG_arg_fail(1)) SWIG_fail;
26403     {
26404         arg2 = (int)(SWIG_As_int(obj1));
26405         if (SWIG_arg_fail(2)) SWIG_fail;
26406     }
26407     {
26408         arg3 = (int)(SWIG_As_int(obj2));
26409         if (SWIG_arg_fail(3)) SWIG_fail;
26410     }
26411     {
26412         PyThreadState* __tstate = wxPyBeginAllowThreads();
26413         result = (bool)(arg1)->ScrollList(arg2,arg3);
26414
26415         wxPyEndAllowThreads(__tstate);
26416         if (PyErr_Occurred()) SWIG_fail;
26417     }
26418     {
26419         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26420     }
26421     return resultobj;
26422     fail:
26423     return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_ListCtrl_SetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
26428     PyObject *resultobj;
26429     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26430     long arg2 ;
26431     wxColour *arg3 = 0 ;
26432     wxColour temp3 ;
26433     PyObject * obj0 = 0 ;
26434     PyObject * obj1 = 0 ;
26435     PyObject * obj2 = 0 ;
26436     char *kwnames[] = {
26437         (char *) "self",(char *) "item",(char *) "col", NULL
26438     };
26439
26440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
26441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26442     if (SWIG_arg_fail(1)) SWIG_fail;
26443     {
26444         arg2 = (long)(SWIG_As_long(obj1));
26445         if (SWIG_arg_fail(2)) SWIG_fail;
26446     }
26447     {
26448         arg3 = &temp3;
26449         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26450     }
26451     {
26452         PyThreadState* __tstate = wxPyBeginAllowThreads();
26453         (arg1)->SetItemTextColour(arg2,(wxColour const &)*arg3);
26454
26455         wxPyEndAllowThreads(__tstate);
26456         if (PyErr_Occurred()) SWIG_fail;
26457     }
26458     Py_INCREF(Py_None); resultobj = Py_None;
26459     return resultobj;
26460     fail:
26461     return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_ListCtrl_GetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
26466     PyObject *resultobj;
26467     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26468     long arg2 ;
26469     wxColour result;
26470     PyObject * obj0 = 0 ;
26471     PyObject * obj1 = 0 ;
26472     char *kwnames[] = {
26473         (char *) "self",(char *) "item", NULL
26474     };
26475
26476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) goto fail;
26477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26478     if (SWIG_arg_fail(1)) SWIG_fail;
26479     {
26480         arg2 = (long)(SWIG_As_long(obj1));
26481         if (SWIG_arg_fail(2)) SWIG_fail;
26482     }
26483     {
26484         PyThreadState* __tstate = wxPyBeginAllowThreads();
26485         result = ((wxPyListCtrl const *)arg1)->GetItemTextColour(arg2);
26486
26487         wxPyEndAllowThreads(__tstate);
26488         if (PyErr_Occurred()) SWIG_fail;
26489     }
26490     {
26491         wxColour * resultptr;
26492         resultptr = new wxColour((wxColour &)(result));
26493         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
26494     }
26495     return resultobj;
26496     fail:
26497     return NULL;
26498 }
26499
26500
26501 static PyObject *_wrap_ListCtrl_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
26502     PyObject *resultobj;
26503     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26504     long arg2 ;
26505     wxColour *arg3 = 0 ;
26506     wxColour temp3 ;
26507     PyObject * obj0 = 0 ;
26508     PyObject * obj1 = 0 ;
26509     PyObject * obj2 = 0 ;
26510     char *kwnames[] = {
26511         (char *) "self",(char *) "item",(char *) "col", NULL
26512     };
26513
26514     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
26515     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26516     if (SWIG_arg_fail(1)) SWIG_fail;
26517     {
26518         arg2 = (long)(SWIG_As_long(obj1));
26519         if (SWIG_arg_fail(2)) SWIG_fail;
26520     }
26521     {
26522         arg3 = &temp3;
26523         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26524     }
26525     {
26526         PyThreadState* __tstate = wxPyBeginAllowThreads();
26527         (arg1)->SetItemBackgroundColour(arg2,(wxColour const &)*arg3);
26528
26529         wxPyEndAllowThreads(__tstate);
26530         if (PyErr_Occurred()) SWIG_fail;
26531     }
26532     Py_INCREF(Py_None); resultobj = Py_None;
26533     return resultobj;
26534     fail:
26535     return NULL;
26536 }
26537
26538
26539 static PyObject *_wrap_ListCtrl_GetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
26540     PyObject *resultobj;
26541     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26542     long arg2 ;
26543     wxColour result;
26544     PyObject * obj0 = 0 ;
26545     PyObject * obj1 = 0 ;
26546     char *kwnames[] = {
26547         (char *) "self",(char *) "item", NULL
26548     };
26549
26550     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
26551     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26552     if (SWIG_arg_fail(1)) SWIG_fail;
26553     {
26554         arg2 = (long)(SWIG_As_long(obj1));
26555         if (SWIG_arg_fail(2)) SWIG_fail;
26556     }
26557     {
26558         PyThreadState* __tstate = wxPyBeginAllowThreads();
26559         result = ((wxPyListCtrl const *)arg1)->GetItemBackgroundColour(arg2);
26560
26561         wxPyEndAllowThreads(__tstate);
26562         if (PyErr_Occurred()) SWIG_fail;
26563     }
26564     {
26565         wxColour * resultptr;
26566         resultptr = new wxColour((wxColour &)(result));
26567         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
26568     }
26569     return resultobj;
26570     fail:
26571     return NULL;
26572 }
26573
26574
26575 static PyObject *_wrap_ListCtrl_SortItems(PyObject *, PyObject *args, PyObject *kwargs) {
26576     PyObject *resultobj;
26577     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26578     PyObject *arg2 = (PyObject *) 0 ;
26579     bool result;
26580     PyObject * obj0 = 0 ;
26581     PyObject * obj1 = 0 ;
26582     char *kwnames[] = {
26583         (char *) "self",(char *) "func", NULL
26584     };
26585
26586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SortItems",kwnames,&obj0,&obj1)) goto fail;
26587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26588     if (SWIG_arg_fail(1)) SWIG_fail;
26589     arg2 = obj1;
26590     {
26591         PyThreadState* __tstate = wxPyBeginAllowThreads();
26592         result = (bool)wxPyListCtrl_SortItems(arg1,arg2);
26593
26594         wxPyEndAllowThreads(__tstate);
26595         if (PyErr_Occurred()) SWIG_fail;
26596     }
26597     {
26598         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26599     }
26600     return resultobj;
26601     fail:
26602     return NULL;
26603 }
26604
26605
26606 static PyObject *_wrap_ListCtrl_GetMainWindow(PyObject *, PyObject *args, PyObject *kwargs) {
26607     PyObject *resultobj;
26608     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26609     wxWindow *result;
26610     PyObject * obj0 = 0 ;
26611     char *kwnames[] = {
26612         (char *) "self", NULL
26613     };
26614
26615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetMainWindow",kwnames,&obj0)) goto fail;
26616     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26617     if (SWIG_arg_fail(1)) SWIG_fail;
26618     {
26619         PyThreadState* __tstate = wxPyBeginAllowThreads();
26620         result = (wxWindow *)wxPyListCtrl_GetMainWindow(arg1);
26621
26622         wxPyEndAllowThreads(__tstate);
26623         if (PyErr_Occurred()) SWIG_fail;
26624     }
26625     {
26626         resultobj = wxPyMake_wxObject(result, 0);
26627     }
26628     return resultobj;
26629     fail:
26630     return NULL;
26631 }
26632
26633
26634 static PyObject *_wrap_ListCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
26635     PyObject *resultobj;
26636     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
26637     wxVisualAttributes result;
26638     PyObject * obj0 = 0 ;
26639     char *kwnames[] = {
26640         (char *) "variant", NULL
26641     };
26642
26643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
26644     if (obj0) {
26645         {
26646             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
26647             if (SWIG_arg_fail(1)) SWIG_fail;
26648         }
26649     }
26650     {
26651         if (!wxPyCheckForApp()) SWIG_fail;
26652         PyThreadState* __tstate = wxPyBeginAllowThreads();
26653         result = wxPyListCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
26654
26655         wxPyEndAllowThreads(__tstate);
26656         if (PyErr_Occurred()) SWIG_fail;
26657     }
26658     {
26659         wxVisualAttributes * resultptr;
26660         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
26661         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
26662     }
26663     return resultobj;
26664     fail:
26665     return NULL;
26666 }
26667
26668
26669 static PyObject * ListCtrl_swigregister(PyObject *, PyObject *args) {
26670     PyObject *obj;
26671     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26672     SWIG_TypeClientData(SWIGTYPE_p_wxPyListCtrl, obj);
26673     Py_INCREF(obj);
26674     return Py_BuildValue((char *)"");
26675 }
26676 static PyObject *_wrap_new_ListView(PyObject *, PyObject *args, PyObject *kwargs) {
26677     PyObject *resultobj;
26678     wxWindow *arg1 = (wxWindow *) 0 ;
26679     int arg2 = (int) -1 ;
26680     wxPoint const &arg3_defvalue = wxDefaultPosition ;
26681     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26682     wxSize const &arg4_defvalue = wxDefaultSize ;
26683     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26684     long arg5 = (long) wxLC_REPORT ;
26685     wxValidator const &arg6_defvalue = wxDefaultValidator ;
26686     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
26687     wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
26688     wxString *arg7 = (wxString *) &arg7_defvalue ;
26689     wxListView *result;
26690     wxPoint temp3 ;
26691     wxSize temp4 ;
26692     bool temp7 = false ;
26693     PyObject * obj0 = 0 ;
26694     PyObject * obj1 = 0 ;
26695     PyObject * obj2 = 0 ;
26696     PyObject * obj3 = 0 ;
26697     PyObject * obj4 = 0 ;
26698     PyObject * obj5 = 0 ;
26699     PyObject * obj6 = 0 ;
26700     char *kwnames[] = {
26701         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
26702     };
26703
26704     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListView",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26705     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706     if (SWIG_arg_fail(1)) SWIG_fail;
26707     if (obj1) {
26708         {
26709             arg2 = (int)(SWIG_As_int(obj1));
26710             if (SWIG_arg_fail(2)) SWIG_fail;
26711         }
26712     }
26713     if (obj2) {
26714         {
26715             arg3 = &temp3;
26716             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26717         }
26718     }
26719     if (obj3) {
26720         {
26721             arg4 = &temp4;
26722             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26723         }
26724     }
26725     if (obj4) {
26726         {
26727             arg5 = (long)(SWIG_As_long(obj4));
26728             if (SWIG_arg_fail(5)) SWIG_fail;
26729         }
26730     }
26731     if (obj5) {
26732         {
26733             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
26734             if (SWIG_arg_fail(6)) SWIG_fail;
26735             if (arg6 == NULL) {
26736                 SWIG_null_ref("wxValidator");
26737             }
26738             if (SWIG_arg_fail(6)) SWIG_fail;
26739         }
26740     }
26741     if (obj6) {
26742         {
26743             arg7 = wxString_in_helper(obj6);
26744             if (arg7 == NULL) SWIG_fail;
26745             temp7 = true;
26746         }
26747     }
26748     {
26749         if (!wxPyCheckForApp()) SWIG_fail;
26750         PyThreadState* __tstate = wxPyBeginAllowThreads();
26751         result = (wxListView *)new wxListView(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
26752
26753         wxPyEndAllowThreads(__tstate);
26754         if (PyErr_Occurred()) SWIG_fail;
26755     }
26756     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 1);
26757     {
26758         if (temp7)
26759         delete arg7;
26760     }
26761     return resultobj;
26762     fail:
26763     {
26764         if (temp7)
26765         delete arg7;
26766     }
26767     return NULL;
26768 }
26769
26770
26771 static PyObject *_wrap_new_PreListView(PyObject *, PyObject *args, PyObject *kwargs) {
26772     PyObject *resultobj;
26773     wxListView *result;
26774     char *kwnames[] = {
26775         NULL
26776     };
26777
26778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListView",kwnames)) goto fail;
26779     {
26780         if (!wxPyCheckForApp()) SWIG_fail;
26781         PyThreadState* __tstate = wxPyBeginAllowThreads();
26782         result = (wxListView *)new wxListView();
26783
26784         wxPyEndAllowThreads(__tstate);
26785         if (PyErr_Occurred()) SWIG_fail;
26786     }
26787     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 1);
26788     return resultobj;
26789     fail:
26790     return NULL;
26791 }
26792
26793
26794 static PyObject *_wrap_ListView_Create(PyObject *, PyObject *args, PyObject *kwargs) {
26795     PyObject *resultobj;
26796     wxListView *arg1 = (wxListView *) 0 ;
26797     wxWindow *arg2 = (wxWindow *) 0 ;
26798     int arg3 = (int) -1 ;
26799     wxPoint const &arg4_defvalue = wxDefaultPosition ;
26800     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
26801     wxSize const &arg5_defvalue = wxDefaultSize ;
26802     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
26803     long arg6 = (long) wxLC_REPORT ;
26804     wxValidator const &arg7_defvalue = wxDefaultValidator ;
26805     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
26806     wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
26807     wxString *arg8 = (wxString *) &arg8_defvalue ;
26808     bool result;
26809     wxPoint temp4 ;
26810     wxSize temp5 ;
26811     bool temp8 = false ;
26812     PyObject * obj0 = 0 ;
26813     PyObject * obj1 = 0 ;
26814     PyObject * obj2 = 0 ;
26815     PyObject * obj3 = 0 ;
26816     PyObject * obj4 = 0 ;
26817     PyObject * obj5 = 0 ;
26818     PyObject * obj6 = 0 ;
26819     PyObject * obj7 = 0 ;
26820     char *kwnames[] = {
26821         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
26822     };
26823
26824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListView_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
26825     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26826     if (SWIG_arg_fail(1)) SWIG_fail;
26827     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26828     if (SWIG_arg_fail(2)) SWIG_fail;
26829     if (obj2) {
26830         {
26831             arg3 = (int)(SWIG_As_int(obj2));
26832             if (SWIG_arg_fail(3)) SWIG_fail;
26833         }
26834     }
26835     if (obj3) {
26836         {
26837             arg4 = &temp4;
26838             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
26839         }
26840     }
26841     if (obj4) {
26842         {
26843             arg5 = &temp5;
26844             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
26845         }
26846     }
26847     if (obj5) {
26848         {
26849             arg6 = (long)(SWIG_As_long(obj5));
26850             if (SWIG_arg_fail(6)) SWIG_fail;
26851         }
26852     }
26853     if (obj6) {
26854         {
26855             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
26856             if (SWIG_arg_fail(7)) SWIG_fail;
26857             if (arg7 == NULL) {
26858                 SWIG_null_ref("wxValidator");
26859             }
26860             if (SWIG_arg_fail(7)) SWIG_fail;
26861         }
26862     }
26863     if (obj7) {
26864         {
26865             arg8 = wxString_in_helper(obj7);
26866             if (arg8 == NULL) SWIG_fail;
26867             temp8 = true;
26868         }
26869     }
26870     {
26871         PyThreadState* __tstate = wxPyBeginAllowThreads();
26872         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
26873
26874         wxPyEndAllowThreads(__tstate);
26875         if (PyErr_Occurred()) SWIG_fail;
26876     }
26877     {
26878         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26879     }
26880     {
26881         if (temp8)
26882         delete arg8;
26883     }
26884     return resultobj;
26885     fail:
26886     {
26887         if (temp8)
26888         delete arg8;
26889     }
26890     return NULL;
26891 }
26892
26893
26894 static PyObject *_wrap_ListView_Select(PyObject *, PyObject *args, PyObject *kwargs) {
26895     PyObject *resultobj;
26896     wxListView *arg1 = (wxListView *) 0 ;
26897     long arg2 ;
26898     bool arg3 = (bool) true ;
26899     PyObject * obj0 = 0 ;
26900     PyObject * obj1 = 0 ;
26901     PyObject * obj2 = 0 ;
26902     char *kwnames[] = {
26903         (char *) "self",(char *) "n",(char *) "on", NULL
26904     };
26905
26906     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListView_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
26907     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26908     if (SWIG_arg_fail(1)) SWIG_fail;
26909     {
26910         arg2 = (long)(SWIG_As_long(obj1));
26911         if (SWIG_arg_fail(2)) SWIG_fail;
26912     }
26913     if (obj2) {
26914         {
26915             arg3 = (bool)(SWIG_As_bool(obj2));
26916             if (SWIG_arg_fail(3)) SWIG_fail;
26917         }
26918     }
26919     {
26920         PyThreadState* __tstate = wxPyBeginAllowThreads();
26921         (arg1)->Select(arg2,arg3);
26922
26923         wxPyEndAllowThreads(__tstate);
26924         if (PyErr_Occurred()) SWIG_fail;
26925     }
26926     Py_INCREF(Py_None); resultobj = Py_None;
26927     return resultobj;
26928     fail:
26929     return NULL;
26930 }
26931
26932
26933 static PyObject *_wrap_ListView_Focus(PyObject *, PyObject *args, PyObject *kwargs) {
26934     PyObject *resultobj;
26935     wxListView *arg1 = (wxListView *) 0 ;
26936     long arg2 ;
26937     PyObject * obj0 = 0 ;
26938     PyObject * obj1 = 0 ;
26939     char *kwnames[] = {
26940         (char *) "self",(char *) "index", NULL
26941     };
26942
26943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_Focus",kwnames,&obj0,&obj1)) goto fail;
26944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26945     if (SWIG_arg_fail(1)) SWIG_fail;
26946     {
26947         arg2 = (long)(SWIG_As_long(obj1));
26948         if (SWIG_arg_fail(2)) SWIG_fail;
26949     }
26950     {
26951         PyThreadState* __tstate = wxPyBeginAllowThreads();
26952         (arg1)->Focus(arg2);
26953
26954         wxPyEndAllowThreads(__tstate);
26955         if (PyErr_Occurred()) SWIG_fail;
26956     }
26957     Py_INCREF(Py_None); resultobj = Py_None;
26958     return resultobj;
26959     fail:
26960     return NULL;
26961 }
26962
26963
26964 static PyObject *_wrap_ListView_GetFocusedItem(PyObject *, PyObject *args, PyObject *kwargs) {
26965     PyObject *resultobj;
26966     wxListView *arg1 = (wxListView *) 0 ;
26967     long result;
26968     PyObject * obj0 = 0 ;
26969     char *kwnames[] = {
26970         (char *) "self", NULL
26971     };
26972
26973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListView_GetFocusedItem",kwnames,&obj0)) goto fail;
26974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26975     if (SWIG_arg_fail(1)) SWIG_fail;
26976     {
26977         PyThreadState* __tstate = wxPyBeginAllowThreads();
26978         result = (long)((wxListView const *)arg1)->GetFocusedItem();
26979
26980         wxPyEndAllowThreads(__tstate);
26981         if (PyErr_Occurred()) SWIG_fail;
26982     }
26983     {
26984         resultobj = SWIG_From_long((long)(result));
26985     }
26986     return resultobj;
26987     fail:
26988     return NULL;
26989 }
26990
26991
26992 static PyObject *_wrap_ListView_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
26993     PyObject *resultobj;
26994     wxListView *arg1 = (wxListView *) 0 ;
26995     long arg2 ;
26996     long result;
26997     PyObject * obj0 = 0 ;
26998     PyObject * obj1 = 0 ;
26999     char *kwnames[] = {
27000         (char *) "self",(char *) "item", NULL
27001     };
27002
27003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
27004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27005     if (SWIG_arg_fail(1)) SWIG_fail;
27006     {
27007         arg2 = (long)(SWIG_As_long(obj1));
27008         if (SWIG_arg_fail(2)) SWIG_fail;
27009     }
27010     {
27011         PyThreadState* __tstate = wxPyBeginAllowThreads();
27012         result = (long)((wxListView const *)arg1)->GetNextSelected(arg2);
27013
27014         wxPyEndAllowThreads(__tstate);
27015         if (PyErr_Occurred()) SWIG_fail;
27016     }
27017     {
27018         resultobj = SWIG_From_long((long)(result));
27019     }
27020     return resultobj;
27021     fail:
27022     return NULL;
27023 }
27024
27025
27026 static PyObject *_wrap_ListView_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
27027     PyObject *resultobj;
27028     wxListView *arg1 = (wxListView *) 0 ;
27029     long result;
27030     PyObject * obj0 = 0 ;
27031     char *kwnames[] = {
27032         (char *) "self", NULL
27033     };
27034
27035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListView_GetFirstSelected",kwnames,&obj0)) goto fail;
27036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27037     if (SWIG_arg_fail(1)) SWIG_fail;
27038     {
27039         PyThreadState* __tstate = wxPyBeginAllowThreads();
27040         result = (long)((wxListView const *)arg1)->GetFirstSelected();
27041
27042         wxPyEndAllowThreads(__tstate);
27043         if (PyErr_Occurred()) SWIG_fail;
27044     }
27045     {
27046         resultobj = SWIG_From_long((long)(result));
27047     }
27048     return resultobj;
27049     fail:
27050     return NULL;
27051 }
27052
27053
27054 static PyObject *_wrap_ListView_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
27055     PyObject *resultobj;
27056     wxListView *arg1 = (wxListView *) 0 ;
27057     long arg2 ;
27058     bool result;
27059     PyObject * obj0 = 0 ;
27060     PyObject * obj1 = 0 ;
27061     char *kwnames[] = {
27062         (char *) "self",(char *) "index", NULL
27063     };
27064
27065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_IsSelected",kwnames,&obj0,&obj1)) goto fail;
27066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27067     if (SWIG_arg_fail(1)) SWIG_fail;
27068     {
27069         arg2 = (long)(SWIG_As_long(obj1));
27070         if (SWIG_arg_fail(2)) SWIG_fail;
27071     }
27072     {
27073         PyThreadState* __tstate = wxPyBeginAllowThreads();
27074         result = (bool)(arg1)->IsSelected(arg2);
27075
27076         wxPyEndAllowThreads(__tstate);
27077         if (PyErr_Occurred()) SWIG_fail;
27078     }
27079     {
27080         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27081     }
27082     return resultobj;
27083     fail:
27084     return NULL;
27085 }
27086
27087
27088 static PyObject *_wrap_ListView_SetColumnImage(PyObject *, PyObject *args, PyObject *kwargs) {
27089     PyObject *resultobj;
27090     wxListView *arg1 = (wxListView *) 0 ;
27091     int arg2 ;
27092     int arg3 ;
27093     PyObject * obj0 = 0 ;
27094     PyObject * obj1 = 0 ;
27095     PyObject * obj2 = 0 ;
27096     char *kwnames[] = {
27097         (char *) "self",(char *) "col",(char *) "image", NULL
27098     };
27099
27100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListView_SetColumnImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27102     if (SWIG_arg_fail(1)) SWIG_fail;
27103     {
27104         arg2 = (int)(SWIG_As_int(obj1));
27105         if (SWIG_arg_fail(2)) SWIG_fail;
27106     }
27107     {
27108         arg3 = (int)(SWIG_As_int(obj2));
27109         if (SWIG_arg_fail(3)) SWIG_fail;
27110     }
27111     {
27112         PyThreadState* __tstate = wxPyBeginAllowThreads();
27113         (arg1)->SetColumnImage(arg2,arg3);
27114
27115         wxPyEndAllowThreads(__tstate);
27116         if (PyErr_Occurred()) SWIG_fail;
27117     }
27118     Py_INCREF(Py_None); resultobj = Py_None;
27119     return resultobj;
27120     fail:
27121     return NULL;
27122 }
27123
27124
27125 static PyObject *_wrap_ListView_ClearColumnImage(PyObject *, PyObject *args, PyObject *kwargs) {
27126     PyObject *resultobj;
27127     wxListView *arg1 = (wxListView *) 0 ;
27128     int arg2 ;
27129     PyObject * obj0 = 0 ;
27130     PyObject * obj1 = 0 ;
27131     char *kwnames[] = {
27132         (char *) "self",(char *) "col", NULL
27133     };
27134
27135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_ClearColumnImage",kwnames,&obj0,&obj1)) goto fail;
27136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27137     if (SWIG_arg_fail(1)) SWIG_fail;
27138     {
27139         arg2 = (int)(SWIG_As_int(obj1));
27140         if (SWIG_arg_fail(2)) SWIG_fail;
27141     }
27142     {
27143         PyThreadState* __tstate = wxPyBeginAllowThreads();
27144         (arg1)->ClearColumnImage(arg2);
27145
27146         wxPyEndAllowThreads(__tstate);
27147         if (PyErr_Occurred()) SWIG_fail;
27148     }
27149     Py_INCREF(Py_None); resultobj = Py_None;
27150     return resultobj;
27151     fail:
27152     return NULL;
27153 }
27154
27155
27156 static PyObject * ListView_swigregister(PyObject *, PyObject *args) {
27157     PyObject *obj;
27158     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27159     SWIG_TypeClientData(SWIGTYPE_p_wxListView, obj);
27160     Py_INCREF(obj);
27161     return Py_BuildValue((char *)"");
27162 }
27163 static int _wrap_TreeCtrlNameStr_set(PyObject *) {
27164     PyErr_SetString(PyExc_TypeError,"Variable TreeCtrlNameStr is read-only.");
27165     return 1;
27166 }
27167
27168
27169 static PyObject *_wrap_TreeCtrlNameStr_get(void) {
27170     PyObject *pyobj;
27171
27172     {
27173 #if wxUSE_UNICODE
27174         pyobj = PyUnicode_FromWideChar((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
27175 #else
27176         pyobj = PyString_FromStringAndSize((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
27177 #endif
27178     }
27179     return pyobj;
27180 }
27181
27182
27183 static PyObject *_wrap_new_TreeItemId(PyObject *, PyObject *args, PyObject *kwargs) {
27184     PyObject *resultobj;
27185     wxTreeItemId *result;
27186     char *kwnames[] = {
27187         NULL
27188     };
27189
27190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TreeItemId",kwnames)) goto fail;
27191     {
27192         PyThreadState* __tstate = wxPyBeginAllowThreads();
27193         result = (wxTreeItemId *)new wxTreeItemId();
27194
27195         wxPyEndAllowThreads(__tstate);
27196         if (PyErr_Occurred()) SWIG_fail;
27197     }
27198     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeItemId, 1);
27199     return resultobj;
27200     fail:
27201     return NULL;
27202 }
27203
27204
27205 static PyObject *_wrap_delete_TreeItemId(PyObject *, PyObject *args, PyObject *kwargs) {
27206     PyObject *resultobj;
27207     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27208     PyObject * obj0 = 0 ;
27209     char *kwnames[] = {
27210         (char *) "self", NULL
27211     };
27212
27213     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TreeItemId",kwnames,&obj0)) goto fail;
27214     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27215     if (SWIG_arg_fail(1)) SWIG_fail;
27216     {
27217         PyThreadState* __tstate = wxPyBeginAllowThreads();
27218         delete arg1;
27219
27220         wxPyEndAllowThreads(__tstate);
27221         if (PyErr_Occurred()) SWIG_fail;
27222     }
27223     Py_INCREF(Py_None); resultobj = Py_None;
27224     return resultobj;
27225     fail:
27226     return NULL;
27227 }
27228
27229
27230 static PyObject *_wrap_TreeItemId_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
27231     PyObject *resultobj;
27232     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27233     bool result;
27234     PyObject * obj0 = 0 ;
27235     char *kwnames[] = {
27236         (char *) "self", NULL
27237     };
27238
27239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemId_IsOk",kwnames,&obj0)) goto fail;
27240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27241     if (SWIG_arg_fail(1)) SWIG_fail;
27242     {
27243         PyThreadState* __tstate = wxPyBeginAllowThreads();
27244         result = (bool)((wxTreeItemId const *)arg1)->IsOk();
27245
27246         wxPyEndAllowThreads(__tstate);
27247         if (PyErr_Occurred()) SWIG_fail;
27248     }
27249     {
27250         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27251     }
27252     return resultobj;
27253     fail:
27254     return NULL;
27255 }
27256
27257
27258 static PyObject *_wrap_TreeItemId___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27259     PyObject *resultobj;
27260     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27261     wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
27262     bool result;
27263     PyObject * obj0 = 0 ;
27264     PyObject * obj1 = 0 ;
27265     char *kwnames[] = {
27266         (char *) "self",(char *) "other", NULL
27267     };
27268
27269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___eq__",kwnames,&obj0,&obj1)) goto fail;
27270     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27271     if (SWIG_arg_fail(1)) SWIG_fail;
27272     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27273     if (SWIG_arg_fail(2)) SWIG_fail;
27274     {
27275         PyThreadState* __tstate = wxPyBeginAllowThreads();
27276         result = (bool)wxTreeItemId___eq__(arg1,(wxTreeItemId const *)arg2);
27277
27278         wxPyEndAllowThreads(__tstate);
27279         if (PyErr_Occurred()) SWIG_fail;
27280     }
27281     {
27282         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27283     }
27284     return resultobj;
27285     fail:
27286     return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_TreeItemId___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27291     PyObject *resultobj;
27292     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27293     wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
27294     bool result;
27295     PyObject * obj0 = 0 ;
27296     PyObject * obj1 = 0 ;
27297     char *kwnames[] = {
27298         (char *) "self",(char *) "other", NULL
27299     };
27300
27301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___ne__",kwnames,&obj0,&obj1)) goto fail;
27302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27303     if (SWIG_arg_fail(1)) SWIG_fail;
27304     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27305     if (SWIG_arg_fail(2)) SWIG_fail;
27306     {
27307         PyThreadState* __tstate = wxPyBeginAllowThreads();
27308         result = (bool)wxTreeItemId___ne__(arg1,(wxTreeItemId const *)arg2);
27309
27310         wxPyEndAllowThreads(__tstate);
27311         if (PyErr_Occurred()) SWIG_fail;
27312     }
27313     {
27314         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27315     }
27316     return resultobj;
27317     fail:
27318     return NULL;
27319 }
27320
27321
27322 static PyObject *_wrap_TreeItemId_m_pItem_set(PyObject *, PyObject *args, PyObject *kwargs) {
27323     PyObject *resultobj;
27324     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27325     void *arg2 = (void *) 0 ;
27326     PyObject * obj0 = 0 ;
27327     PyObject * obj1 = 0 ;
27328     char *kwnames[] = {
27329         (char *) "self",(char *) "m_pItem", NULL
27330     };
27331
27332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId_m_pItem_set",kwnames,&obj0,&obj1)) goto fail;
27333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27334     if (SWIG_arg_fail(1)) SWIG_fail;
27335     {
27336         if ((SWIG_ConvertPtr(obj1,(void **)(&arg2),0,SWIG_POINTER_EXCEPTION|SWIG_POINTER_DISOWN))== -1) {
27337             SWIG_arg_fail(2);SWIG_fail;
27338         }
27339     }
27340     if (arg1) (arg1)->m_pItem = arg2;
27341
27342     Py_INCREF(Py_None); resultobj = Py_None;
27343     return resultobj;
27344     fail:
27345     return NULL;
27346 }
27347
27348
27349 static PyObject *_wrap_TreeItemId_m_pItem_get(PyObject *, PyObject *args, PyObject *kwargs) {
27350     PyObject *resultobj;
27351     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27352     void *result;
27353     PyObject * obj0 = 0 ;
27354     char *kwnames[] = {
27355         (char *) "self", NULL
27356     };
27357
27358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemId_m_pItem_get",kwnames,&obj0)) goto fail;
27359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27360     if (SWIG_arg_fail(1)) SWIG_fail;
27361     result = (void *) ((arg1)->m_pItem);
27362
27363     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
27364     return resultobj;
27365     fail:
27366     return NULL;
27367 }
27368
27369
27370 static PyObject * TreeItemId_swigregister(PyObject *, PyObject *args) {
27371     PyObject *obj;
27372     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27373     SWIG_TypeClientData(SWIGTYPE_p_wxTreeItemId, obj);
27374     Py_INCREF(obj);
27375     return Py_BuildValue((char *)"");
27376 }
27377 static PyObject *_wrap_new_TreeItemData(PyObject *, PyObject *args, PyObject *kwargs) {
27378     PyObject *resultobj;
27379     PyObject *arg1 = (PyObject *) NULL ;
27380     wxPyTreeItemData *result;
27381     PyObject * obj0 = 0 ;
27382     char *kwnames[] = {
27383         (char *) "obj", NULL
27384     };
27385
27386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TreeItemData",kwnames,&obj0)) goto fail;
27387     if (obj0) {
27388         arg1 = obj0;
27389     }
27390     {
27391         PyThreadState* __tstate = wxPyBeginAllowThreads();
27392         result = (wxPyTreeItemData *)new wxPyTreeItemData(arg1);
27393
27394         wxPyEndAllowThreads(__tstate);
27395         if (PyErr_Occurred()) SWIG_fail;
27396     }
27397     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeItemData, 1);
27398     return resultobj;
27399     fail:
27400     return NULL;
27401 }
27402
27403
27404 static PyObject *_wrap_TreeItemData_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27405     PyObject *resultobj;
27406     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27407     PyObject *result;
27408     PyObject * obj0 = 0 ;
27409     char *kwnames[] = {
27410         (char *) "self", NULL
27411     };
27412
27413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_GetData",kwnames,&obj0)) goto fail;
27414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27415     if (SWIG_arg_fail(1)) SWIG_fail;
27416     {
27417         PyThreadState* __tstate = wxPyBeginAllowThreads();
27418         result = (PyObject *)(arg1)->GetData();
27419
27420         wxPyEndAllowThreads(__tstate);
27421         if (PyErr_Occurred()) SWIG_fail;
27422     }
27423     resultobj = result;
27424     return resultobj;
27425     fail:
27426     return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_TreeItemData_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27431     PyObject *resultobj;
27432     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27433     PyObject *arg2 = (PyObject *) 0 ;
27434     PyObject * obj0 = 0 ;
27435     PyObject * obj1 = 0 ;
27436     char *kwnames[] = {
27437         (char *) "self",(char *) "obj", NULL
27438     };
27439
27440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetData",kwnames,&obj0,&obj1)) goto fail;
27441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27442     if (SWIG_arg_fail(1)) SWIG_fail;
27443     arg2 = obj1;
27444     {
27445         PyThreadState* __tstate = wxPyBeginAllowThreads();
27446         (arg1)->SetData(arg2);
27447
27448         wxPyEndAllowThreads(__tstate);
27449         if (PyErr_Occurred()) SWIG_fail;
27450     }
27451     Py_INCREF(Py_None); resultobj = Py_None;
27452     return resultobj;
27453     fail:
27454     return NULL;
27455 }
27456
27457
27458 static PyObject *_wrap_TreeItemData_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27459     PyObject *resultobj;
27460     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27461     wxTreeItemId *result;
27462     PyObject * obj0 = 0 ;
27463     char *kwnames[] = {
27464         (char *) "self", NULL
27465     };
27466
27467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_GetId",kwnames,&obj0)) goto fail;
27468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27469     if (SWIG_arg_fail(1)) SWIG_fail;
27470     {
27471         PyThreadState* __tstate = wxPyBeginAllowThreads();
27472         {
27473             wxTreeItemId const &_result_ref = (arg1)->GetId();
27474             result = (wxTreeItemId *) &_result_ref;
27475         }
27476
27477         wxPyEndAllowThreads(__tstate);
27478         if (PyErr_Occurred()) SWIG_fail;
27479     }
27480     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeItemId, 0);
27481     return resultobj;
27482     fail:
27483     return NULL;
27484 }
27485
27486
27487 static PyObject *_wrap_TreeItemData_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27488     PyObject *resultobj;
27489     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27490     wxTreeItemId *arg2 = 0 ;
27491     PyObject * obj0 = 0 ;
27492     PyObject * obj1 = 0 ;
27493     char *kwnames[] = {
27494         (char *) "self",(char *) "id", NULL
27495     };
27496
27497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetId",kwnames,&obj0,&obj1)) goto fail;
27498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27499     if (SWIG_arg_fail(1)) SWIG_fail;
27500     {
27501         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27502         if (SWIG_arg_fail(2)) SWIG_fail;
27503         if (arg2 == NULL) {
27504             SWIG_null_ref("wxTreeItemId");
27505         }
27506         if (SWIG_arg_fail(2)) SWIG_fail;
27507     }
27508     {
27509         PyThreadState* __tstate = wxPyBeginAllowThreads();
27510         (arg1)->SetId((wxTreeItemId const &)*arg2);
27511
27512         wxPyEndAllowThreads(__tstate);
27513         if (PyErr_Occurred()) SWIG_fail;
27514     }
27515     Py_INCREF(Py_None); resultobj = Py_None;
27516     return resultobj;
27517     fail:
27518     return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_TreeItemData_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
27523     PyObject *resultobj;
27524     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27525     PyObject * obj0 = 0 ;
27526     char *kwnames[] = {
27527         (char *) "self", NULL
27528     };
27529
27530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_Destroy",kwnames,&obj0)) goto fail;
27531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27532     if (SWIG_arg_fail(1)) SWIG_fail;
27533     {
27534         PyThreadState* __tstate = wxPyBeginAllowThreads();
27535         wxPyTreeItemData_Destroy(arg1);
27536
27537         wxPyEndAllowThreads(__tstate);
27538         if (PyErr_Occurred()) SWIG_fail;
27539     }
27540     Py_INCREF(Py_None); resultobj = Py_None;
27541     return resultobj;
27542     fail:
27543     return NULL;
27544 }
27545
27546
27547 static PyObject * TreeItemData_swigregister(PyObject *, PyObject *args) {
27548     PyObject *obj;
27549     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27550     SWIG_TypeClientData(SWIGTYPE_p_wxPyTreeItemData, obj);
27551     Py_INCREF(obj);
27552     return Py_BuildValue((char *)"");
27553 }
27554 static PyObject *_wrap_new_TreeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27555     PyObject *resultobj;
27556     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27557     int arg2 = (int) 0 ;
27558     wxTreeEvent *result;
27559     PyObject * obj0 = 0 ;
27560     PyObject * obj1 = 0 ;
27561     char *kwnames[] = {
27562         (char *) "commandType",(char *) "id", NULL
27563     };
27564
27565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TreeEvent",kwnames,&obj0,&obj1)) goto fail;
27566     if (obj0) {
27567         {
27568             arg1 = (wxEventType)(SWIG_As_int(obj0));
27569             if (SWIG_arg_fail(1)) SWIG_fail;
27570         }
27571     }
27572     if (obj1) {
27573         {
27574             arg2 = (int)(SWIG_As_int(obj1));
27575             if (SWIG_arg_fail(2)) SWIG_fail;
27576         }
27577     }
27578     {
27579         PyThreadState* __tstate = wxPyBeginAllowThreads();
27580         result = (wxTreeEvent *)new wxTreeEvent(arg1,arg2);
27581
27582         wxPyEndAllowThreads(__tstate);
27583         if (PyErr_Occurred()) SWIG_fail;
27584     }
27585     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeEvent, 1);
27586     return resultobj;
27587     fail:
27588     return NULL;
27589 }
27590
27591
27592 static PyObject *_wrap_TreeEvent_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
27593     PyObject *resultobj;
27594     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27595     wxTreeItemId result;
27596     PyObject * obj0 = 0 ;
27597     char *kwnames[] = {
27598         (char *) "self", NULL
27599     };
27600
27601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetItem",kwnames,&obj0)) goto fail;
27602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27603     if (SWIG_arg_fail(1)) SWIG_fail;
27604     {
27605         PyThreadState* __tstate = wxPyBeginAllowThreads();
27606         result = ((wxTreeEvent const *)arg1)->GetItem();
27607
27608         wxPyEndAllowThreads(__tstate);
27609         if (PyErr_Occurred()) SWIG_fail;
27610     }
27611     {
27612         wxTreeItemId * resultptr;
27613         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
27614         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
27615     }
27616     return resultobj;
27617     fail:
27618     return NULL;
27619 }
27620
27621
27622 static PyObject *_wrap_TreeEvent_SetItem(PyObject *, PyObject *args, PyObject *kwargs) {
27623     PyObject *resultobj;
27624     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27625     wxTreeItemId *arg2 = 0 ;
27626     PyObject * obj0 = 0 ;
27627     PyObject * obj1 = 0 ;
27628     char *kwnames[] = {
27629         (char *) "self",(char *) "item", NULL
27630     };
27631
27632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetItem",kwnames,&obj0,&obj1)) goto fail;
27633     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27634     if (SWIG_arg_fail(1)) SWIG_fail;
27635     {
27636         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27637         if (SWIG_arg_fail(2)) SWIG_fail;
27638         if (arg2 == NULL) {
27639             SWIG_null_ref("wxTreeItemId");
27640         }
27641         if (SWIG_arg_fail(2)) SWIG_fail;
27642     }
27643     {
27644         PyThreadState* __tstate = wxPyBeginAllowThreads();
27645         (arg1)->SetItem((wxTreeItemId const &)*arg2);
27646
27647         wxPyEndAllowThreads(__tstate);
27648         if (PyErr_Occurred()) SWIG_fail;
27649     }
27650     Py_INCREF(Py_None); resultobj = Py_None;
27651     return resultobj;
27652     fail:
27653     return NULL;
27654 }
27655
27656
27657 static PyObject *_wrap_TreeEvent_GetOldItem(PyObject *, PyObject *args, PyObject *kwargs) {
27658     PyObject *resultobj;
27659     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27660     wxTreeItemId result;
27661     PyObject * obj0 = 0 ;
27662     char *kwnames[] = {
27663         (char *) "self", NULL
27664     };
27665
27666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetOldItem",kwnames,&obj0)) goto fail;
27667     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27668     if (SWIG_arg_fail(1)) SWIG_fail;
27669     {
27670         PyThreadState* __tstate = wxPyBeginAllowThreads();
27671         result = ((wxTreeEvent const *)arg1)->GetOldItem();
27672
27673         wxPyEndAllowThreads(__tstate);
27674         if (PyErr_Occurred()) SWIG_fail;
27675     }
27676     {
27677         wxTreeItemId * resultptr;
27678         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
27679         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
27680     }
27681     return resultobj;
27682     fail:
27683     return NULL;
27684 }
27685
27686
27687 static PyObject *_wrap_TreeEvent_SetOldItem(PyObject *, PyObject *args, PyObject *kwargs) {
27688     PyObject *resultobj;
27689     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27690     wxTreeItemId *arg2 = 0 ;
27691     PyObject * obj0 = 0 ;
27692     PyObject * obj1 = 0 ;
27693     char *kwnames[] = {
27694         (char *) "self",(char *) "item", NULL
27695     };
27696
27697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetOldItem",kwnames,&obj0,&obj1)) goto fail;
27698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27699     if (SWIG_arg_fail(1)) SWIG_fail;
27700     {
27701         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27702         if (SWIG_arg_fail(2)) SWIG_fail;
27703         if (arg2 == NULL) {
27704             SWIG_null_ref("wxTreeItemId");
27705         }
27706         if (SWIG_arg_fail(2)) SWIG_fail;
27707     }
27708     {
27709         PyThreadState* __tstate = wxPyBeginAllowThreads();
27710         (arg1)->SetOldItem((wxTreeItemId const &)*arg2);
27711
27712         wxPyEndAllowThreads(__tstate);
27713         if (PyErr_Occurred()) SWIG_fail;
27714     }
27715     Py_INCREF(Py_None); resultobj = Py_None;
27716     return resultobj;
27717     fail:
27718     return NULL;
27719 }
27720
27721
27722 static PyObject *_wrap_TreeEvent_GetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
27723     PyObject *resultobj;
27724     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27725     wxPoint result;
27726     PyObject * obj0 = 0 ;
27727     char *kwnames[] = {
27728         (char *) "self", NULL
27729     };
27730
27731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetPoint",kwnames,&obj0)) goto fail;
27732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27733     if (SWIG_arg_fail(1)) SWIG_fail;
27734     {
27735         PyThreadState* __tstate = wxPyBeginAllowThreads();
27736         result = ((wxTreeEvent const *)arg1)->GetPoint();
27737
27738         wxPyEndAllowThreads(__tstate);
27739         if (PyErr_Occurred()) SWIG_fail;
27740     }
27741     {
27742         wxPoint * resultptr;
27743         resultptr = new wxPoint((wxPoint &)(result));
27744         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27745     }
27746     return resultobj;
27747     fail:
27748     return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_TreeEvent_SetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
27753     PyObject *resultobj;
27754     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27755     wxPoint *arg2 = 0 ;
27756     wxPoint temp2 ;
27757     PyObject * obj0 = 0 ;
27758     PyObject * obj1 = 0 ;
27759     char *kwnames[] = {
27760         (char *) "self",(char *) "pt", NULL
27761     };
27762
27763     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetPoint",kwnames,&obj0,&obj1)) goto fail;
27764     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27765     if (SWIG_arg_fail(1)) SWIG_fail;
27766     {
27767         arg2 = &temp2;
27768         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27769     }
27770     {
27771         PyThreadState* __tstate = wxPyBeginAllowThreads();
27772         (arg1)->SetPoint((wxPoint const &)*arg2);
27773
27774         wxPyEndAllowThreads(__tstate);
27775         if (PyErr_Occurred()) SWIG_fail;
27776     }
27777     Py_INCREF(Py_None); resultobj = Py_None;
27778     return resultobj;
27779     fail:
27780     return NULL;
27781 }
27782
27783
27784 static PyObject *_wrap_TreeEvent_GetKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27785     PyObject *resultobj;
27786     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27787     wxKeyEvent *result;
27788     PyObject * obj0 = 0 ;
27789     char *kwnames[] = {
27790         (char *) "self", NULL
27791     };
27792
27793     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetKeyEvent",kwnames,&obj0)) goto fail;
27794     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27795     if (SWIG_arg_fail(1)) SWIG_fail;
27796     {
27797         PyThreadState* __tstate = wxPyBeginAllowThreads();
27798         {
27799             wxKeyEvent const &_result_ref = ((wxTreeEvent const *)arg1)->GetKeyEvent();
27800             result = (wxKeyEvent *) &_result_ref;
27801         }
27802
27803         wxPyEndAllowThreads(__tstate);
27804         if (PyErr_Occurred()) SWIG_fail;
27805     }
27806     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 0);
27807     return resultobj;
27808     fail:
27809     return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_TreeEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
27814     PyObject *resultobj;
27815     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27816     int result;
27817     PyObject * obj0 = 0 ;
27818     char *kwnames[] = {
27819         (char *) "self", NULL
27820     };
27821
27822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetKeyCode",kwnames,&obj0)) goto fail;
27823     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27824     if (SWIG_arg_fail(1)) SWIG_fail;
27825     {
27826         PyThreadState* __tstate = wxPyBeginAllowThreads();
27827         result = (int)((wxTreeEvent const *)arg1)->GetKeyCode();
27828
27829         wxPyEndAllowThreads(__tstate);
27830         if (PyErr_Occurred()) SWIG_fail;
27831     }
27832     {
27833         resultobj = SWIG_From_int((int)(result));
27834     }
27835     return resultobj;
27836     fail:
27837     return NULL;
27838 }
27839
27840
27841 static PyObject *_wrap_TreeEvent_SetKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27842     PyObject *resultobj;
27843     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27844     wxKeyEvent *arg2 = 0 ;
27845     PyObject * obj0 = 0 ;
27846     PyObject * obj1 = 0 ;
27847     char *kwnames[] = {
27848         (char *) "self",(char *) "evt", NULL
27849     };
27850
27851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetKeyEvent",kwnames,&obj0,&obj1)) goto fail;
27852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27853     if (SWIG_arg_fail(1)) SWIG_fail;
27854     {
27855         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
27856         if (SWIG_arg_fail(2)) SWIG_fail;
27857         if (arg2 == NULL) {
27858             SWIG_null_ref("wxKeyEvent");
27859         }
27860         if (SWIG_arg_fail(2)) SWIG_fail;
27861     }
27862     {
27863         PyThreadState* __tstate = wxPyBeginAllowThreads();
27864         (arg1)->SetKeyEvent((wxKeyEvent const &)*arg2);
27865
27866         wxPyEndAllowThreads(__tstate);
27867         if (PyErr_Occurred()) SWIG_fail;
27868     }
27869     Py_INCREF(Py_None); resultobj = Py_None;
27870     return resultobj;
27871     fail:
27872     return NULL;
27873 }
27874
27875
27876 static PyObject *_wrap_TreeEvent_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
27877     PyObject *resultobj;
27878     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27879     wxString *result;
27880     PyObject * obj0 = 0 ;
27881     char *kwnames[] = {
27882         (char *) "self", NULL
27883     };
27884
27885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetLabel",kwnames,&obj0)) goto fail;
27886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27887     if (SWIG_arg_fail(1)) SWIG_fail;
27888     {
27889         PyThreadState* __tstate = wxPyBeginAllowThreads();
27890         {
27891             wxString const &_result_ref = ((wxTreeEvent const *)arg1)->GetLabel();
27892             result = (wxString *) &_result_ref;
27893         }
27894
27895         wxPyEndAllowThreads(__tstate);
27896         if (PyErr_Occurred()) SWIG_fail;
27897     }
27898     {
27899 #if wxUSE_UNICODE
27900         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27901 #else
27902         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27903 #endif
27904     }
27905     return resultobj;
27906     fail:
27907     return NULL;
27908 }
27909
27910
27911 static PyObject *_wrap_TreeEvent_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
27912     PyObject *resultobj;
27913     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27914     wxString *arg2 = 0 ;
27915     bool temp2 = false ;
27916     PyObject * obj0 = 0 ;
27917     PyObject * obj1 = 0 ;
27918     char *kwnames[] = {
27919         (char *) "self",(char *) "label", NULL
27920     };
27921
27922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetLabel",kwnames,&obj0,&obj1)) goto fail;
27923     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27924     if (SWIG_arg_fail(1)) SWIG_fail;
27925     {
27926         arg2 = wxString_in_helper(obj1);
27927         if (arg2 == NULL) SWIG_fail;
27928         temp2 = true;
27929     }
27930     {
27931         PyThreadState* __tstate = wxPyBeginAllowThreads();
27932         (arg1)->SetLabel((wxString const &)*arg2);
27933
27934         wxPyEndAllowThreads(__tstate);
27935         if (PyErr_Occurred()) SWIG_fail;
27936     }
27937     Py_INCREF(Py_None); resultobj = Py_None;
27938     {
27939         if (temp2)
27940         delete arg2;
27941     }
27942     return resultobj;
27943     fail:
27944     {
27945         if (temp2)
27946         delete arg2;
27947     }
27948     return NULL;
27949 }
27950
27951
27952 static PyObject *_wrap_TreeEvent_IsEditCancelled(PyObject *, PyObject *args, PyObject *kwargs) {
27953     PyObject *resultobj;
27954     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27955     bool result;
27956     PyObject * obj0 = 0 ;
27957     char *kwnames[] = {
27958         (char *) "self", NULL
27959     };
27960
27961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_IsEditCancelled",kwnames,&obj0)) goto fail;
27962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27963     if (SWIG_arg_fail(1)) SWIG_fail;
27964     {
27965         PyThreadState* __tstate = wxPyBeginAllowThreads();
27966         result = (bool)((wxTreeEvent const *)arg1)->IsEditCancelled();
27967
27968         wxPyEndAllowThreads(__tstate);
27969         if (PyErr_Occurred()) SWIG_fail;
27970     }
27971     {
27972         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973     }
27974     return resultobj;
27975     fail:
27976     return NULL;
27977 }
27978
27979
27980 static PyObject *_wrap_TreeEvent_SetEditCanceled(PyObject *, PyObject *args, PyObject *kwargs) {
27981     PyObject *resultobj;
27982     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27983     bool arg2 ;
27984     PyObject * obj0 = 0 ;
27985     PyObject * obj1 = 0 ;
27986     char *kwnames[] = {
27987         (char *) "self",(char *) "editCancelled", NULL
27988     };
27989
27990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetEditCanceled",kwnames,&obj0,&obj1)) goto fail;
27991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27992     if (SWIG_arg_fail(1)) SWIG_fail;
27993     {
27994         arg2 = (bool)(SWIG_As_bool(obj1));
27995         if (SWIG_arg_fail(2)) SWIG_fail;
27996     }
27997     {
27998         PyThreadState* __tstate = wxPyBeginAllowThreads();
27999         (arg1)->SetEditCanceled(arg2);
28000
28001         wxPyEndAllowThreads(__tstate);
28002         if (PyErr_Occurred()) SWIG_fail;
28003     }
28004     Py_INCREF(Py_None); resultobj = Py_None;
28005     return resultobj;
28006     fail:
28007     return NULL;
28008 }
28009
28010
28011 static PyObject *_wrap_TreeEvent_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
28012     PyObject *resultobj;
28013     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
28014     wxString *arg2 = 0 ;
28015     bool temp2 = false ;
28016     PyObject * obj0 = 0 ;
28017     PyObject * obj1 = 0 ;
28018     char *kwnames[] = {
28019         (char *) "self",(char *) "toolTip", NULL
28020     };
28021
28022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
28023     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
28024     if (SWIG_arg_fail(1)) SWIG_fail;
28025     {
28026         arg2 = wxString_in_helper(obj1);
28027         if (arg2 == NULL) SWIG_fail;
28028         temp2 = true;
28029     }
28030     {
28031         PyThreadState* __tstate = wxPyBeginAllowThreads();
28032         (arg1)->SetToolTip((wxString const &)*arg2);
28033
28034         wxPyEndAllowThreads(__tstate);
28035         if (PyErr_Occurred()) SWIG_fail;
28036     }
28037     Py_INCREF(Py_None); resultobj = Py_None;
28038     {
28039         if (temp2)
28040         delete arg2;
28041     }
28042     return resultobj;
28043     fail:
28044     {
28045         if (temp2)
28046         delete arg2;
28047     }
28048     return NULL;
28049 }
28050
28051
28052 static PyObject * TreeEvent_swigregister(PyObject *, PyObject *args) {
28053     PyObject *obj;
28054     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28055     SWIG_TypeClientData(SWIGTYPE_p_wxTreeEvent, obj);
28056     Py_INCREF(obj);
28057     return Py_BuildValue((char *)"");
28058 }
28059 static PyObject *_wrap_new_TreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
28060     PyObject *resultobj;
28061     wxWindow *arg1 = (wxWindow *) 0 ;
28062     int arg2 = (int) -1 ;
28063     wxPoint const &arg3_defvalue = wxDefaultPosition ;
28064     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
28065     wxSize const &arg4_defvalue = wxDefaultSize ;
28066     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
28067     long arg5 = (long) wxTR_DEFAULT_STYLE ;
28068     wxValidator const &arg6_defvalue = wxDefaultValidator ;
28069     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
28070     wxString const &arg7_defvalue = wxPyTreeCtrlNameStr ;
28071     wxString *arg7 = (wxString *) &arg7_defvalue ;
28072     wxPyTreeCtrl *result;
28073     wxPoint temp3 ;
28074     wxSize temp4 ;
28075     bool temp7 = false ;
28076     PyObject * obj0 = 0 ;
28077     PyObject * obj1 = 0 ;
28078     PyObject * obj2 = 0 ;
28079     PyObject * obj3 = 0 ;
28080     PyObject * obj4 = 0 ;
28081     PyObject * obj5 = 0 ;
28082     PyObject * obj6 = 0 ;
28083     char *kwnames[] = {
28084         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
28085     };
28086
28087     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_TreeCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
28088     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28089     if (SWIG_arg_fail(1)) SWIG_fail;
28090     if (obj1) {
28091         {
28092             arg2 = (int)(SWIG_As_int(obj1));
28093             if (SWIG_arg_fail(2)) SWIG_fail;
28094         }
28095     }
28096     if (obj2) {
28097         {
28098             arg3 = &temp3;
28099             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28100         }
28101     }
28102     if (obj3) {
28103         {
28104             arg4 = &temp4;
28105             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
28106         }
28107     }
28108     if (obj4) {
28109         {
28110             arg5 = (long)(SWIG_As_long(obj4));
28111             if (SWIG_arg_fail(5)) SWIG_fail;
28112         }
28113     }
28114     if (obj5) {
28115         {
28116             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28117             if (SWIG_arg_fail(6)) SWIG_fail;
28118             if (arg6 == NULL) {
28119                 SWIG_null_ref("wxValidator");
28120             }
28121             if (SWIG_arg_fail(6)) SWIG_fail;
28122         }
28123     }
28124     if (obj6) {
28125         {
28126             arg7 = wxString_in_helper(obj6);
28127             if (arg7 == NULL) SWIG_fail;
28128             temp7 = true;
28129         }
28130     }
28131     {
28132         if (!wxPyCheckForApp()) SWIG_fail;
28133         PyThreadState* __tstate = wxPyBeginAllowThreads();
28134         result = (wxPyTreeCtrl *)new wxPyTreeCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
28135
28136         wxPyEndAllowThreads(__tstate);
28137         if (PyErr_Occurred()) SWIG_fail;
28138     }
28139     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeCtrl, 1);
28140     {
28141         if (temp7)
28142         delete arg7;
28143     }
28144     return resultobj;
28145     fail:
28146     {
28147         if (temp7)
28148         delete arg7;
28149     }
28150     return NULL;
28151 }
28152
28153
28154 static PyObject *_wrap_new_PreTreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
28155     PyObject *resultobj;
28156     wxPyTreeCtrl *result;
28157     char *kwnames[] = {
28158         NULL
28159     };
28160
28161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreTreeCtrl",kwnames)) goto fail;
28162     {
28163         if (!wxPyCheckForApp()) SWIG_fail;
28164         PyThreadState* __tstate = wxPyBeginAllowThreads();
28165         result = (wxPyTreeCtrl *)new wxPyTreeCtrl();
28166
28167         wxPyEndAllowThreads(__tstate);
28168         if (PyErr_Occurred()) SWIG_fail;
28169     }
28170     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeCtrl, 1);
28171     return resultobj;
28172     fail:
28173     return NULL;
28174 }
28175
28176
28177 static PyObject *_wrap_TreeCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
28178     PyObject *resultobj;
28179     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28180     wxWindow *arg2 = (wxWindow *) 0 ;
28181     int arg3 = (int) -1 ;
28182     wxPoint const &arg4_defvalue = wxDefaultPosition ;
28183     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
28184     wxSize const &arg5_defvalue = wxDefaultSize ;
28185     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
28186     long arg6 = (long) wxTR_DEFAULT_STYLE ;
28187     wxValidator const &arg7_defvalue = wxDefaultValidator ;
28188     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
28189     wxString const &arg8_defvalue = wxPyTreeCtrlNameStr ;
28190     wxString *arg8 = (wxString *) &arg8_defvalue ;
28191     bool result;
28192     wxPoint temp4 ;
28193     wxSize temp5 ;
28194     bool temp8 = false ;
28195     PyObject * obj0 = 0 ;
28196     PyObject * obj1 = 0 ;
28197     PyObject * obj2 = 0 ;
28198     PyObject * obj3 = 0 ;
28199     PyObject * obj4 = 0 ;
28200     PyObject * obj5 = 0 ;
28201     PyObject * obj6 = 0 ;
28202     PyObject * obj7 = 0 ;
28203     char *kwnames[] = {
28204         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
28205     };
28206
28207     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:TreeCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
28208     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28209     if (SWIG_arg_fail(1)) SWIG_fail;
28210     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28211     if (SWIG_arg_fail(2)) SWIG_fail;
28212     if (obj2) {
28213         {
28214             arg3 = (int)(SWIG_As_int(obj2));
28215             if (SWIG_arg_fail(3)) SWIG_fail;
28216         }
28217     }
28218     if (obj3) {
28219         {
28220             arg4 = &temp4;
28221             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
28222         }
28223     }
28224     if (obj4) {
28225         {
28226             arg5 = &temp5;
28227             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
28228         }
28229     }
28230     if (obj5) {
28231         {
28232             arg6 = (long)(SWIG_As_long(obj5));
28233             if (SWIG_arg_fail(6)) SWIG_fail;
28234         }
28235     }
28236     if (obj6) {
28237         {
28238             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28239             if (SWIG_arg_fail(7)) SWIG_fail;
28240             if (arg7 == NULL) {
28241                 SWIG_null_ref("wxValidator");
28242             }
28243             if (SWIG_arg_fail(7)) SWIG_fail;
28244         }
28245     }
28246     if (obj7) {
28247         {
28248             arg8 = wxString_in_helper(obj7);
28249             if (arg8 == NULL) SWIG_fail;
28250             temp8 = true;
28251         }
28252     }
28253     {
28254         PyThreadState* __tstate = wxPyBeginAllowThreads();
28255         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
28256
28257         wxPyEndAllowThreads(__tstate);
28258         if (PyErr_Occurred()) SWIG_fail;
28259     }
28260     {
28261         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28262     }
28263     {
28264         if (temp8)
28265         delete arg8;
28266     }
28267     return resultobj;
28268     fail:
28269     {
28270         if (temp8)
28271         delete arg8;
28272     }
28273     return NULL;
28274 }
28275
28276
28277 static PyObject *_wrap_TreeCtrl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28278     PyObject *resultobj;
28279     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28280     PyObject *arg2 = (PyObject *) 0 ;
28281     PyObject *arg3 = (PyObject *) 0 ;
28282     PyObject * obj0 = 0 ;
28283     PyObject * obj1 = 0 ;
28284     PyObject * obj2 = 0 ;
28285     char *kwnames[] = {
28286         (char *) "self",(char *) "self",(char *) "_class", NULL
28287     };
28288
28289     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28290     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28291     if (SWIG_arg_fail(1)) SWIG_fail;
28292     arg2 = obj1;
28293     arg3 = obj2;
28294     {
28295         PyThreadState* __tstate = wxPyBeginAllowThreads();
28296         (arg1)->_setCallbackInfo(arg2,arg3);
28297
28298         wxPyEndAllowThreads(__tstate);
28299         if (PyErr_Occurred()) SWIG_fail;
28300     }
28301     Py_INCREF(Py_None); resultobj = Py_None;
28302     return resultobj;
28303     fail:
28304     return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_TreeCtrl_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
28309     PyObject *resultobj;
28310     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28311     size_t result;
28312     PyObject * obj0 = 0 ;
28313     char *kwnames[] = {
28314         (char *) "self", NULL
28315     };
28316
28317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetCount",kwnames,&obj0)) goto fail;
28318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28319     if (SWIG_arg_fail(1)) SWIG_fail;
28320     {
28321         PyThreadState* __tstate = wxPyBeginAllowThreads();
28322         result = (size_t)((wxPyTreeCtrl const *)arg1)->GetCount();
28323
28324         wxPyEndAllowThreads(__tstate);
28325         if (PyErr_Occurred()) SWIG_fail;
28326     }
28327     {
28328         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28329     }
28330     return resultobj;
28331     fail:
28332     return NULL;
28333 }
28334
28335
28336 static PyObject *_wrap_TreeCtrl_GetIndent(PyObject *, PyObject *args, PyObject *kwargs) {
28337     PyObject *resultobj;
28338     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28339     unsigned int result;
28340     PyObject * obj0 = 0 ;
28341     char *kwnames[] = {
28342         (char *) "self", NULL
28343     };
28344
28345     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetIndent",kwnames,&obj0)) goto fail;
28346     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28347     if (SWIG_arg_fail(1)) SWIG_fail;
28348     {
28349         PyThreadState* __tstate = wxPyBeginAllowThreads();
28350         result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetIndent();
28351
28352         wxPyEndAllowThreads(__tstate);
28353         if (PyErr_Occurred()) SWIG_fail;
28354     }
28355     {
28356         resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
28357     }
28358     return resultobj;
28359     fail:
28360     return NULL;
28361 }
28362
28363
28364 static PyObject *_wrap_TreeCtrl_SetIndent(PyObject *, PyObject *args, PyObject *kwargs) {
28365     PyObject *resultobj;
28366     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28367     unsigned int arg2 ;
28368     PyObject * obj0 = 0 ;
28369     PyObject * obj1 = 0 ;
28370     char *kwnames[] = {
28371         (char *) "self",(char *) "indent", NULL
28372     };
28373
28374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetIndent",kwnames,&obj0,&obj1)) goto fail;
28375     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28376     if (SWIG_arg_fail(1)) SWIG_fail;
28377     {
28378         arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
28379         if (SWIG_arg_fail(2)) SWIG_fail;
28380     }
28381     {
28382         PyThreadState* __tstate = wxPyBeginAllowThreads();
28383         (arg1)->SetIndent(arg2);
28384
28385         wxPyEndAllowThreads(__tstate);
28386         if (PyErr_Occurred()) SWIG_fail;
28387     }
28388     Py_INCREF(Py_None); resultobj = Py_None;
28389     return resultobj;
28390     fail:
28391     return NULL;
28392 }
28393
28394
28395 static PyObject *_wrap_TreeCtrl_GetSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
28396     PyObject *resultobj;
28397     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28398     unsigned int result;
28399     PyObject * obj0 = 0 ;
28400     char *kwnames[] = {
28401         (char *) "self", NULL
28402     };
28403
28404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSpacing",kwnames,&obj0)) goto fail;
28405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28406     if (SWIG_arg_fail(1)) SWIG_fail;
28407     {
28408         PyThreadState* __tstate = wxPyBeginAllowThreads();
28409         result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetSpacing();
28410
28411         wxPyEndAllowThreads(__tstate);
28412         if (PyErr_Occurred()) SWIG_fail;
28413     }
28414     {
28415         resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
28416     }
28417     return resultobj;
28418     fail:
28419     return NULL;
28420 }
28421
28422
28423 static PyObject *_wrap_TreeCtrl_SetSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
28424     PyObject *resultobj;
28425     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28426     unsigned int arg2 ;
28427     PyObject * obj0 = 0 ;
28428     PyObject * obj1 = 0 ;
28429     char *kwnames[] = {
28430         (char *) "self",(char *) "spacing", NULL
28431     };
28432
28433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetSpacing",kwnames,&obj0,&obj1)) goto fail;
28434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28435     if (SWIG_arg_fail(1)) SWIG_fail;
28436     {
28437         arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
28438         if (SWIG_arg_fail(2)) SWIG_fail;
28439     }
28440     {
28441         PyThreadState* __tstate = wxPyBeginAllowThreads();
28442         (arg1)->SetSpacing(arg2);
28443
28444         wxPyEndAllowThreads(__tstate);
28445         if (PyErr_Occurred()) SWIG_fail;
28446     }
28447     Py_INCREF(Py_None); resultobj = Py_None;
28448     return resultobj;
28449     fail:
28450     return NULL;
28451 }
28452
28453
28454 static PyObject *_wrap_TreeCtrl_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28455     PyObject *resultobj;
28456     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28457     wxImageList *result;
28458     PyObject * obj0 = 0 ;
28459     char *kwnames[] = {
28460         (char *) "self", NULL
28461     };
28462
28463     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetImageList",kwnames,&obj0)) goto fail;
28464     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28465     if (SWIG_arg_fail(1)) SWIG_fail;
28466     {
28467         PyThreadState* __tstate = wxPyBeginAllowThreads();
28468         result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetImageList();
28469
28470         wxPyEndAllowThreads(__tstate);
28471         if (PyErr_Occurred()) SWIG_fail;
28472     }
28473     {
28474         resultobj = wxPyMake_wxObject(result, 0);
28475     }
28476     return resultobj;
28477     fail:
28478     return NULL;
28479 }
28480
28481
28482 static PyObject *_wrap_TreeCtrl_GetStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28483     PyObject *resultobj;
28484     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28485     wxImageList *result;
28486     PyObject * obj0 = 0 ;
28487     char *kwnames[] = {
28488         (char *) "self", NULL
28489     };
28490
28491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetStateImageList",kwnames,&obj0)) goto fail;
28492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28493     if (SWIG_arg_fail(1)) SWIG_fail;
28494     {
28495         PyThreadState* __tstate = wxPyBeginAllowThreads();
28496         result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetStateImageList();
28497
28498         wxPyEndAllowThreads(__tstate);
28499         if (PyErr_Occurred()) SWIG_fail;
28500     }
28501     {
28502         resultobj = wxPyMake_wxObject(result, 0);
28503     }
28504     return resultobj;
28505     fail:
28506     return NULL;
28507 }
28508
28509
28510 static PyObject *_wrap_TreeCtrl_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28511     PyObject *resultobj;
28512     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28513     wxImageList *arg2 = (wxImageList *) 0 ;
28514     PyObject * obj0 = 0 ;
28515     PyObject * obj1 = 0 ;
28516     char *kwnames[] = {
28517         (char *) "self",(char *) "imageList", NULL
28518     };
28519
28520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetImageList",kwnames,&obj0,&obj1)) goto fail;
28521     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28522     if (SWIG_arg_fail(1)) SWIG_fail;
28523     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
28524     if (SWIG_arg_fail(2)) SWIG_fail;
28525     {
28526         PyThreadState* __tstate = wxPyBeginAllowThreads();
28527         (arg1)->SetImageList(arg2);
28528
28529         wxPyEndAllowThreads(__tstate);
28530         if (PyErr_Occurred()) SWIG_fail;
28531     }
28532     Py_INCREF(Py_None); resultobj = Py_None;
28533     return resultobj;
28534     fail:
28535     return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_TreeCtrl_SetStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28540     PyObject *resultobj;
28541     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28542     wxImageList *arg2 = (wxImageList *) 0 ;
28543     PyObject * obj0 = 0 ;
28544     PyObject * obj1 = 0 ;
28545     char *kwnames[] = {
28546         (char *) "self",(char *) "imageList", NULL
28547     };
28548
28549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetStateImageList",kwnames,&obj0,&obj1)) goto fail;
28550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28551     if (SWIG_arg_fail(1)) SWIG_fail;
28552     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
28553     if (SWIG_arg_fail(2)) SWIG_fail;
28554     {
28555         PyThreadState* __tstate = wxPyBeginAllowThreads();
28556         (arg1)->SetStateImageList(arg2);
28557
28558         wxPyEndAllowThreads(__tstate);
28559         if (PyErr_Occurred()) SWIG_fail;
28560     }
28561     Py_INCREF(Py_None); resultobj = Py_None;
28562     return resultobj;
28563     fail:
28564     return NULL;
28565 }
28566
28567
28568 static PyObject *_wrap_TreeCtrl_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28569     PyObject *resultobj;
28570     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28571     wxImageList *arg2 = (wxImageList *) 0 ;
28572     PyObject * obj0 = 0 ;
28573     PyObject * obj1 = 0 ;
28574     char *kwnames[] = {
28575         (char *) "self",(char *) "imageList", NULL
28576     };
28577
28578     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignImageList",kwnames,&obj0,&obj1)) goto fail;
28579     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28580     if (SWIG_arg_fail(1)) SWIG_fail;
28581     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28582     if (SWIG_arg_fail(2)) SWIG_fail;
28583     {
28584         PyThreadState* __tstate = wxPyBeginAllowThreads();
28585         (arg1)->AssignImageList(arg2);
28586
28587         wxPyEndAllowThreads(__tstate);
28588         if (PyErr_Occurred()) SWIG_fail;
28589     }
28590     Py_INCREF(Py_None); resultobj = Py_None;
28591     return resultobj;
28592     fail:
28593     return NULL;
28594 }
28595
28596
28597 static PyObject *_wrap_TreeCtrl_AssignStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28598     PyObject *resultobj;
28599     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28600     wxImageList *arg2 = (wxImageList *) 0 ;
28601     PyObject * obj0 = 0 ;
28602     PyObject * obj1 = 0 ;
28603     char *kwnames[] = {
28604         (char *) "self",(char *) "imageList", NULL
28605     };
28606
28607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignStateImageList",kwnames,&obj0,&obj1)) goto fail;
28608     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28609     if (SWIG_arg_fail(1)) SWIG_fail;
28610     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28611     if (SWIG_arg_fail(2)) SWIG_fail;
28612     {
28613         PyThreadState* __tstate = wxPyBeginAllowThreads();
28614         (arg1)->AssignStateImageList(arg2);
28615
28616         wxPyEndAllowThreads(__tstate);
28617         if (PyErr_Occurred()) SWIG_fail;
28618     }
28619     Py_INCREF(Py_None); resultobj = Py_None;
28620     return resultobj;
28621     fail:
28622     return NULL;
28623 }
28624
28625
28626 static PyObject *_wrap_TreeCtrl_GetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
28627     PyObject *resultobj;
28628     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28629     wxTreeItemId *arg2 = 0 ;
28630     wxString result;
28631     PyObject * obj0 = 0 ;
28632     PyObject * obj1 = 0 ;
28633     char *kwnames[] = {
28634         (char *) "self",(char *) "item", NULL
28635     };
28636
28637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemText",kwnames,&obj0,&obj1)) goto fail;
28638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28639     if (SWIG_arg_fail(1)) SWIG_fail;
28640     {
28641         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28642         if (SWIG_arg_fail(2)) SWIG_fail;
28643         if (arg2 == NULL) {
28644             SWIG_null_ref("wxTreeItemId");
28645         }
28646         if (SWIG_arg_fail(2)) SWIG_fail;
28647     }
28648     {
28649         PyThreadState* __tstate = wxPyBeginAllowThreads();
28650         result = ((wxPyTreeCtrl const *)arg1)->GetItemText((wxTreeItemId const &)*arg2);
28651
28652         wxPyEndAllowThreads(__tstate);
28653         if (PyErr_Occurred()) SWIG_fail;
28654     }
28655     {
28656 #if wxUSE_UNICODE
28657         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28658 #else
28659         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28660 #endif
28661     }
28662     return resultobj;
28663     fail:
28664     return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_TreeCtrl_GetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
28669     PyObject *resultobj;
28670     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28671     wxTreeItemId *arg2 = 0 ;
28672     wxTreeItemIcon arg3 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
28673     int result;
28674     PyObject * obj0 = 0 ;
28675     PyObject * obj1 = 0 ;
28676     PyObject * obj2 = 0 ;
28677     char *kwnames[] = {
28678         (char *) "self",(char *) "item",(char *) "which", NULL
28679     };
28680
28681     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetItemImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
28682     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28683     if (SWIG_arg_fail(1)) SWIG_fail;
28684     {
28685         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28686         if (SWIG_arg_fail(2)) SWIG_fail;
28687         if (arg2 == NULL) {
28688             SWIG_null_ref("wxTreeItemId");
28689         }
28690         if (SWIG_arg_fail(2)) SWIG_fail;
28691     }
28692     if (obj2) {
28693         {
28694             arg3 = (wxTreeItemIcon)(SWIG_As_int(obj2));
28695             if (SWIG_arg_fail(3)) SWIG_fail;
28696         }
28697     }
28698     {
28699         PyThreadState* __tstate = wxPyBeginAllowThreads();
28700         result = (int)((wxPyTreeCtrl const *)arg1)->GetItemImage((wxTreeItemId const &)*arg2,(wxTreeItemIcon )arg3);
28701
28702         wxPyEndAllowThreads(__tstate);
28703         if (PyErr_Occurred()) SWIG_fail;
28704     }
28705     {
28706         resultobj = SWIG_From_int((int)(result));
28707     }
28708     return resultobj;
28709     fail:
28710     return NULL;
28711 }
28712
28713
28714 static PyObject *_wrap_TreeCtrl_GetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
28715     PyObject *resultobj;
28716     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28717     wxTreeItemId *arg2 = 0 ;
28718     wxPyTreeItemData *result;
28719     PyObject * obj0 = 0 ;
28720     PyObject * obj1 = 0 ;
28721     char *kwnames[] = {
28722         (char *) "self",(char *) "item", NULL
28723     };
28724
28725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemData",kwnames,&obj0,&obj1)) goto fail;
28726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28727     if (SWIG_arg_fail(1)) SWIG_fail;
28728     {
28729         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28730         if (SWIG_arg_fail(2)) SWIG_fail;
28731         if (arg2 == NULL) {
28732             SWIG_null_ref("wxTreeItemId");
28733         }
28734         if (SWIG_arg_fail(2)) SWIG_fail;
28735     }
28736     {
28737         PyThreadState* __tstate = wxPyBeginAllowThreads();
28738         result = (wxPyTreeItemData *)wxPyTreeCtrl_GetItemData(arg1,(wxTreeItemId const &)*arg2);
28739
28740         wxPyEndAllowThreads(__tstate);
28741         if (PyErr_Occurred()) SWIG_fail;
28742     }
28743     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeItemData, 0);
28744     return resultobj;
28745     fail:
28746     return NULL;
28747 }
28748
28749
28750 static PyObject *_wrap_TreeCtrl_GetItemPyData(PyObject *, PyObject *args, PyObject *kwargs) {
28751     PyObject *resultobj;
28752     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28753     wxTreeItemId *arg2 = 0 ;
28754     PyObject *result;
28755     PyObject * obj0 = 0 ;
28756     PyObject * obj1 = 0 ;
28757     char *kwnames[] = {
28758         (char *) "self",(char *) "item", NULL
28759     };
28760
28761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemPyData",kwnames,&obj0,&obj1)) goto fail;
28762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28763     if (SWIG_arg_fail(1)) SWIG_fail;
28764     {
28765         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28766         if (SWIG_arg_fail(2)) SWIG_fail;
28767         if (arg2 == NULL) {
28768             SWIG_null_ref("wxTreeItemId");
28769         }
28770         if (SWIG_arg_fail(2)) SWIG_fail;
28771     }
28772     {
28773         PyThreadState* __tstate = wxPyBeginAllowThreads();
28774         result = (PyObject *)wxPyTreeCtrl_GetItemPyData(arg1,(wxTreeItemId const &)*arg2);
28775
28776         wxPyEndAllowThreads(__tstate);
28777         if (PyErr_Occurred()) SWIG_fail;
28778     }
28779     resultobj = result;
28780     return resultobj;
28781     fail:
28782     return NULL;
28783 }
28784
28785
28786 static PyObject *_wrap_TreeCtrl_GetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
28787     PyObject *resultobj;
28788     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28789     wxTreeItemId *arg2 = 0 ;
28790     wxColour result;
28791     PyObject * obj0 = 0 ;
28792     PyObject * obj1 = 0 ;
28793     char *kwnames[] = {
28794         (char *) "self",(char *) "item", NULL
28795     };
28796
28797     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) goto fail;
28798     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28799     if (SWIG_arg_fail(1)) SWIG_fail;
28800     {
28801         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28802         if (SWIG_arg_fail(2)) SWIG_fail;
28803         if (arg2 == NULL) {
28804             SWIG_null_ref("wxTreeItemId");
28805         }
28806         if (SWIG_arg_fail(2)) SWIG_fail;
28807     }
28808     {
28809         PyThreadState* __tstate = wxPyBeginAllowThreads();
28810         result = ((wxPyTreeCtrl const *)arg1)->GetItemTextColour((wxTreeItemId const &)*arg2);
28811
28812         wxPyEndAllowThreads(__tstate);
28813         if (PyErr_Occurred()) SWIG_fail;
28814     }
28815     {
28816         wxColour * resultptr;
28817         resultptr = new wxColour((wxColour &)(result));
28818         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28819     }
28820     return resultobj;
28821     fail:
28822     return NULL;
28823 }
28824
28825
28826 static PyObject *_wrap_TreeCtrl_GetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28827     PyObject *resultobj;
28828     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28829     wxTreeItemId *arg2 = 0 ;
28830     wxColour result;
28831     PyObject * obj0 = 0 ;
28832     PyObject * obj1 = 0 ;
28833     char *kwnames[] = {
28834         (char *) "self",(char *) "item", NULL
28835     };
28836
28837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28839     if (SWIG_arg_fail(1)) SWIG_fail;
28840     {
28841         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28842         if (SWIG_arg_fail(2)) SWIG_fail;
28843         if (arg2 == NULL) {
28844             SWIG_null_ref("wxTreeItemId");
28845         }
28846         if (SWIG_arg_fail(2)) SWIG_fail;
28847     }
28848     {
28849         PyThreadState* __tstate = wxPyBeginAllowThreads();
28850         result = ((wxPyTreeCtrl const *)arg1)->GetItemBackgroundColour((wxTreeItemId const &)*arg2);
28851
28852         wxPyEndAllowThreads(__tstate);
28853         if (PyErr_Occurred()) SWIG_fail;
28854     }
28855     {
28856         wxColour * resultptr;
28857         resultptr = new wxColour((wxColour &)(result));
28858         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28859     }
28860     return resultobj;
28861     fail:
28862     return NULL;
28863 }
28864
28865
28866 static PyObject *_wrap_TreeCtrl_GetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
28867     PyObject *resultobj;
28868     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28869     wxTreeItemId *arg2 = 0 ;
28870     wxFont result;
28871     PyObject * obj0 = 0 ;
28872     PyObject * obj1 = 0 ;
28873     char *kwnames[] = {
28874         (char *) "self",(char *) "item", NULL
28875     };
28876
28877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemFont",kwnames,&obj0,&obj1)) goto fail;
28878     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28879     if (SWIG_arg_fail(1)) SWIG_fail;
28880     {
28881         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28882         if (SWIG_arg_fail(2)) SWIG_fail;
28883         if (arg2 == NULL) {
28884             SWIG_null_ref("wxTreeItemId");
28885         }
28886         if (SWIG_arg_fail(2)) SWIG_fail;
28887     }
28888     {
28889         PyThreadState* __tstate = wxPyBeginAllowThreads();
28890         result = ((wxPyTreeCtrl const *)arg1)->GetItemFont((wxTreeItemId const &)*arg2);
28891
28892         wxPyEndAllowThreads(__tstate);
28893         if (PyErr_Occurred()) SWIG_fail;
28894     }
28895     {
28896         wxFont * resultptr;
28897         resultptr = new wxFont((wxFont &)(result));
28898         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
28899     }
28900     return resultobj;
28901     fail:
28902     return NULL;
28903 }
28904
28905
28906 static PyObject *_wrap_TreeCtrl_SetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
28907     PyObject *resultobj;
28908     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28909     wxTreeItemId *arg2 = 0 ;
28910     wxString *arg3 = 0 ;
28911     bool temp3 = false ;
28912     PyObject * obj0 = 0 ;
28913     PyObject * obj1 = 0 ;
28914     PyObject * obj2 = 0 ;
28915     char *kwnames[] = {
28916         (char *) "self",(char *) "item",(char *) "text", NULL
28917     };
28918
28919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) goto fail;
28920     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28921     if (SWIG_arg_fail(1)) SWIG_fail;
28922     {
28923         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28924         if (SWIG_arg_fail(2)) SWIG_fail;
28925         if (arg2 == NULL) {
28926             SWIG_null_ref("wxTreeItemId");
28927         }
28928         if (SWIG_arg_fail(2)) SWIG_fail;
28929     }
28930     {
28931         arg3 = wxString_in_helper(obj2);
28932         if (arg3 == NULL) SWIG_fail;
28933         temp3 = true;
28934     }
28935     {
28936         PyThreadState* __tstate = wxPyBeginAllowThreads();
28937         (arg1)->SetItemText((wxTreeItemId const &)*arg2,(wxString const &)*arg3);
28938
28939         wxPyEndAllowThreads(__tstate);
28940         if (PyErr_Occurred()) SWIG_fail;
28941     }
28942     Py_INCREF(Py_None); resultobj = Py_None;
28943     {
28944         if (temp3)
28945         delete arg3;
28946     }
28947     return resultobj;
28948     fail:
28949     {
28950         if (temp3)
28951         delete arg3;
28952     }
28953     return NULL;
28954 }
28955
28956
28957 static PyObject *_wrap_TreeCtrl_SetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
28958     PyObject *resultobj;
28959     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28960     wxTreeItemId *arg2 = 0 ;
28961     int arg3 ;
28962     wxTreeItemIcon arg4 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
28963     PyObject * obj0 = 0 ;
28964     PyObject * obj1 = 0 ;
28965     PyObject * obj2 = 0 ;
28966     PyObject * obj3 = 0 ;
28967     char *kwnames[] = {
28968         (char *) "self",(char *) "item",(char *) "image",(char *) "which", NULL
28969     };
28970
28971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:TreeCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28973     if (SWIG_arg_fail(1)) SWIG_fail;
28974     {
28975         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28976         if (SWIG_arg_fail(2)) SWIG_fail;
28977         if (arg2 == NULL) {
28978             SWIG_null_ref("wxTreeItemId");
28979         }
28980         if (SWIG_arg_fail(2)) SWIG_fail;
28981     }
28982     {
28983         arg3 = (int)(SWIG_As_int(obj2));
28984         if (SWIG_arg_fail(3)) SWIG_fail;
28985     }
28986     if (obj3) {
28987         {
28988             arg4 = (wxTreeItemIcon)(SWIG_As_int(obj3));
28989             if (SWIG_arg_fail(4)) SWIG_fail;
28990         }
28991     }
28992     {
28993         PyThreadState* __tstate = wxPyBeginAllowThreads();
28994         (arg1)->SetItemImage((wxTreeItemId const &)*arg2,arg3,(wxTreeItemIcon )arg4);
28995
28996         wxPyEndAllowThreads(__tstate);
28997         if (PyErr_Occurred()) SWIG_fail;
28998     }
28999     Py_INCREF(Py_None); resultobj = Py_None;
29000     return resultobj;
29001     fail:
29002     return NULL;
29003 }
29004
29005
29006 static PyObject *_wrap_TreeCtrl_SetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
29007     PyObject *resultobj;
29008     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29009     wxTreeItemId *arg2 = 0 ;
29010     wxPyTreeItemData *arg3 = (wxPyTreeItemData *) 0 ;
29011     PyObject * obj0 = 0 ;
29012     PyObject * obj1 = 0 ;
29013     PyObject * obj2 = 0 ;
29014     char *kwnames[] = {
29015         (char *) "self",(char *) "item",(char *) "data", NULL
29016     };
29017
29018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
29019     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29020     if (SWIG_arg_fail(1)) SWIG_fail;
29021     {
29022         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29023         if (SWIG_arg_fail(2)) SWIG_fail;
29024         if (arg2 == NULL) {
29025             SWIG_null_ref("wxTreeItemId");
29026         }
29027         if (SWIG_arg_fail(2)) SWIG_fail;
29028     }
29029     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
29030     if (SWIG_arg_fail(3)) SWIG_fail;
29031     {
29032         PyThreadState* __tstate = wxPyBeginAllowThreads();
29033         wxPyTreeCtrl_SetItemData(arg1,(wxTreeItemId const &)*arg2,arg3);
29034
29035         wxPyEndAllowThreads(__tstate);
29036         if (PyErr_Occurred()) SWIG_fail;
29037     }
29038     Py_INCREF(Py_None); resultobj = Py_None;
29039     return resultobj;
29040     fail:
29041     return NULL;
29042 }
29043
29044
29045 static PyObject *_wrap_TreeCtrl_SetItemPyData(PyObject *, PyObject *args, PyObject *kwargs) {
29046     PyObject *resultobj;
29047     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29048     wxTreeItemId *arg2 = 0 ;
29049     PyObject *arg3 = (PyObject *) 0 ;
29050     PyObject * obj0 = 0 ;
29051     PyObject * obj1 = 0 ;
29052     PyObject * obj2 = 0 ;
29053     char *kwnames[] = {
29054         (char *) "self",(char *) "item",(char *) "obj", NULL
29055     };
29056
29057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemPyData",kwnames,&obj0,&obj1,&obj2)) goto fail;
29058     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29059     if (SWIG_arg_fail(1)) SWIG_fail;
29060     {
29061         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29062         if (SWIG_arg_fail(2)) SWIG_fail;
29063         if (arg2 == NULL) {
29064             SWIG_null_ref("wxTreeItemId");
29065         }
29066         if (SWIG_arg_fail(2)) SWIG_fail;
29067     }
29068     arg3 = obj2;
29069     {
29070         PyThreadState* __tstate = wxPyBeginAllowThreads();
29071         wxPyTreeCtrl_SetItemPyData(arg1,(wxTreeItemId const &)*arg2,arg3);
29072
29073         wxPyEndAllowThreads(__tstate);
29074         if (PyErr_Occurred()) SWIG_fail;
29075     }
29076     Py_INCREF(Py_None); resultobj = Py_None;
29077     return resultobj;
29078     fail:
29079     return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_TreeCtrl_SetItemHasChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29084     PyObject *resultobj;
29085     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29086     wxTreeItemId *arg2 = 0 ;
29087     bool arg3 = (bool) true ;
29088     PyObject * obj0 = 0 ;
29089     PyObject * obj1 = 0 ;
29090     PyObject * obj2 = 0 ;
29091     char *kwnames[] = {
29092         (char *) "self",(char *) "item",(char *) "has", NULL
29093     };
29094
29095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemHasChildren",kwnames,&obj0,&obj1,&obj2)) goto fail;
29096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29097     if (SWIG_arg_fail(1)) SWIG_fail;
29098     {
29099         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29100         if (SWIG_arg_fail(2)) SWIG_fail;
29101         if (arg2 == NULL) {
29102             SWIG_null_ref("wxTreeItemId");
29103         }
29104         if (SWIG_arg_fail(2)) SWIG_fail;
29105     }
29106     if (obj2) {
29107         {
29108             arg3 = (bool)(SWIG_As_bool(obj2));
29109             if (SWIG_arg_fail(3)) SWIG_fail;
29110         }
29111     }
29112     {
29113         PyThreadState* __tstate = wxPyBeginAllowThreads();
29114         (arg1)->SetItemHasChildren((wxTreeItemId const &)*arg2,arg3);
29115
29116         wxPyEndAllowThreads(__tstate);
29117         if (PyErr_Occurred()) SWIG_fail;
29118     }
29119     Py_INCREF(Py_None); resultobj = Py_None;
29120     return resultobj;
29121     fail:
29122     return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_TreeCtrl_SetItemBold(PyObject *, PyObject *args, PyObject *kwargs) {
29127     PyObject *resultobj;
29128     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29129     wxTreeItemId *arg2 = 0 ;
29130     bool arg3 = (bool) true ;
29131     PyObject * obj0 = 0 ;
29132     PyObject * obj1 = 0 ;
29133     PyObject * obj2 = 0 ;
29134     char *kwnames[] = {
29135         (char *) "self",(char *) "item",(char *) "bold", NULL
29136     };
29137
29138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemBold",kwnames,&obj0,&obj1,&obj2)) goto fail;
29139     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29140     if (SWIG_arg_fail(1)) SWIG_fail;
29141     {
29142         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29143         if (SWIG_arg_fail(2)) SWIG_fail;
29144         if (arg2 == NULL) {
29145             SWIG_null_ref("wxTreeItemId");
29146         }
29147         if (SWIG_arg_fail(2)) SWIG_fail;
29148     }
29149     if (obj2) {
29150         {
29151             arg3 = (bool)(SWIG_As_bool(obj2));
29152             if (SWIG_arg_fail(3)) SWIG_fail;
29153         }
29154     }
29155     {
29156         PyThreadState* __tstate = wxPyBeginAllowThreads();
29157         (arg1)->SetItemBold((wxTreeItemId const &)*arg2,arg3);
29158
29159         wxPyEndAllowThreads(__tstate);
29160         if (PyErr_Occurred()) SWIG_fail;
29161     }
29162     Py_INCREF(Py_None); resultobj = Py_None;
29163     return resultobj;
29164     fail:
29165     return NULL;
29166 }
29167
29168
29169 static PyObject *_wrap_TreeCtrl_SetItemDropHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
29170     PyObject *resultobj;
29171     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29172     wxTreeItemId *arg2 = 0 ;
29173     bool arg3 = (bool) true ;
29174     PyObject * obj0 = 0 ;
29175     PyObject * obj1 = 0 ;
29176     PyObject * obj2 = 0 ;
29177     char *kwnames[] = {
29178         (char *) "self",(char *) "item",(char *) "highlight", NULL
29179     };
29180
29181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemDropHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
29182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29183     if (SWIG_arg_fail(1)) SWIG_fail;
29184     {
29185         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29186         if (SWIG_arg_fail(2)) SWIG_fail;
29187         if (arg2 == NULL) {
29188             SWIG_null_ref("wxTreeItemId");
29189         }
29190         if (SWIG_arg_fail(2)) SWIG_fail;
29191     }
29192     if (obj2) {
29193         {
29194             arg3 = (bool)(SWIG_As_bool(obj2));
29195             if (SWIG_arg_fail(3)) SWIG_fail;
29196         }
29197     }
29198     {
29199         PyThreadState* __tstate = wxPyBeginAllowThreads();
29200         (arg1)->SetItemDropHighlight((wxTreeItemId const &)*arg2,arg3);
29201
29202         wxPyEndAllowThreads(__tstate);
29203         if (PyErr_Occurred()) SWIG_fail;
29204     }
29205     Py_INCREF(Py_None); resultobj = Py_None;
29206     return resultobj;
29207     fail:
29208     return NULL;
29209 }
29210
29211
29212 static PyObject *_wrap_TreeCtrl_SetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
29213     PyObject *resultobj;
29214     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29215     wxTreeItemId *arg2 = 0 ;
29216     wxColour *arg3 = 0 ;
29217     wxColour temp3 ;
29218     PyObject * obj0 = 0 ;
29219     PyObject * obj1 = 0 ;
29220     PyObject * obj2 = 0 ;
29221     char *kwnames[] = {
29222         (char *) "self",(char *) "item",(char *) "col", NULL
29223     };
29224
29225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
29226     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29227     if (SWIG_arg_fail(1)) SWIG_fail;
29228     {
29229         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29230         if (SWIG_arg_fail(2)) SWIG_fail;
29231         if (arg2 == NULL) {
29232             SWIG_null_ref("wxTreeItemId");
29233         }
29234         if (SWIG_arg_fail(2)) SWIG_fail;
29235     }
29236     {
29237         arg3 = &temp3;
29238         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
29239     }
29240     {
29241         PyThreadState* __tstate = wxPyBeginAllowThreads();
29242         (arg1)->SetItemTextColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
29243
29244         wxPyEndAllowThreads(__tstate);
29245         if (PyErr_Occurred()) SWIG_fail;
29246     }
29247     Py_INCREF(Py_None); resultobj = Py_None;
29248     return resultobj;
29249     fail:
29250     return NULL;
29251 }
29252
29253
29254 static PyObject *_wrap_TreeCtrl_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29255     PyObject *resultobj;
29256     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29257     wxTreeItemId *arg2 = 0 ;
29258     wxColour *arg3 = 0 ;
29259     wxColour temp3 ;
29260     PyObject * obj0 = 0 ;
29261     PyObject * obj1 = 0 ;
29262     PyObject * obj2 = 0 ;
29263     char *kwnames[] = {
29264         (char *) "self",(char *) "item",(char *) "col", NULL
29265     };
29266
29267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
29268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29269     if (SWIG_arg_fail(1)) SWIG_fail;
29270     {
29271         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29272         if (SWIG_arg_fail(2)) SWIG_fail;
29273         if (arg2 == NULL) {
29274             SWIG_null_ref("wxTreeItemId");
29275         }
29276         if (SWIG_arg_fail(2)) SWIG_fail;
29277     }
29278     {
29279         arg3 = &temp3;
29280         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
29281     }
29282     {
29283         PyThreadState* __tstate = wxPyBeginAllowThreads();
29284         (arg1)->SetItemBackgroundColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
29285
29286         wxPyEndAllowThreads(__tstate);
29287         if (PyErr_Occurred()) SWIG_fail;
29288     }
29289     Py_INCREF(Py_None); resultobj = Py_None;
29290     return resultobj;
29291     fail:
29292     return NULL;
29293 }
29294
29295
29296 static PyObject *_wrap_TreeCtrl_SetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
29297     PyObject *resultobj;
29298     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29299     wxTreeItemId *arg2 = 0 ;
29300     wxFont *arg3 = 0 ;
29301     PyObject * obj0 = 0 ;
29302     PyObject * obj1 = 0 ;
29303     PyObject * obj2 = 0 ;
29304     char *kwnames[] = {
29305         (char *) "self",(char *) "item",(char *) "font", NULL
29306     };
29307
29308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
29309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29310     if (SWIG_arg_fail(1)) SWIG_fail;
29311     {
29312         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29313         if (SWIG_arg_fail(2)) SWIG_fail;
29314         if (arg2 == NULL) {
29315             SWIG_null_ref("wxTreeItemId");
29316         }
29317         if (SWIG_arg_fail(2)) SWIG_fail;
29318     }
29319     {
29320         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29321         if (SWIG_arg_fail(3)) SWIG_fail;
29322         if (arg3 == NULL) {
29323             SWIG_null_ref("wxFont");
29324         }
29325         if (SWIG_arg_fail(3)) SWIG_fail;
29326     }
29327     {
29328         PyThreadState* __tstate = wxPyBeginAllowThreads();
29329         (arg1)->SetItemFont((wxTreeItemId const &)*arg2,(wxFont const &)*arg3);
29330
29331         wxPyEndAllowThreads(__tstate);
29332         if (PyErr_Occurred()) SWIG_fail;
29333     }
29334     Py_INCREF(Py_None); resultobj = Py_None;
29335     return resultobj;
29336     fail:
29337     return NULL;
29338 }
29339
29340
29341 static PyObject *_wrap_TreeCtrl_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
29342     PyObject *resultobj;
29343     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29344     wxTreeItemId *arg2 = 0 ;
29345     bool result;
29346     PyObject * obj0 = 0 ;
29347     PyObject * obj1 = 0 ;
29348     char *kwnames[] = {
29349         (char *) "self",(char *) "item", NULL
29350     };
29351
29352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsVisible",kwnames,&obj0,&obj1)) goto fail;
29353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29354     if (SWIG_arg_fail(1)) SWIG_fail;
29355     {
29356         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29357         if (SWIG_arg_fail(2)) SWIG_fail;
29358         if (arg2 == NULL) {
29359             SWIG_null_ref("wxTreeItemId");
29360         }
29361         if (SWIG_arg_fail(2)) SWIG_fail;
29362     }
29363     {
29364         PyThreadState* __tstate = wxPyBeginAllowThreads();
29365         result = (bool)((wxPyTreeCtrl const *)arg1)->IsVisible((wxTreeItemId const &)*arg2);
29366
29367         wxPyEndAllowThreads(__tstate);
29368         if (PyErr_Occurred()) SWIG_fail;
29369     }
29370     {
29371         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29372     }
29373     return resultobj;
29374     fail:
29375     return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_TreeCtrl_ItemHasChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29380     PyObject *resultobj;
29381     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29382     wxTreeItemId *arg2 = 0 ;
29383     bool result;
29384     PyObject * obj0 = 0 ;
29385     PyObject * obj1 = 0 ;
29386     char *kwnames[] = {
29387         (char *) "self",(char *) "item", NULL
29388     };
29389
29390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ItemHasChildren",kwnames,&obj0,&obj1)) goto fail;
29391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29392     if (SWIG_arg_fail(1)) SWIG_fail;
29393     {
29394         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29395         if (SWIG_arg_fail(2)) SWIG_fail;
29396         if (arg2 == NULL) {
29397             SWIG_null_ref("wxTreeItemId");
29398         }
29399         if (SWIG_arg_fail(2)) SWIG_fail;
29400     }
29401     {
29402         PyThreadState* __tstate = wxPyBeginAllowThreads();
29403         result = (bool)((wxPyTreeCtrl const *)arg1)->ItemHasChildren((wxTreeItemId const &)*arg2);
29404
29405         wxPyEndAllowThreads(__tstate);
29406         if (PyErr_Occurred()) SWIG_fail;
29407     }
29408     {
29409         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29410     }
29411     return resultobj;
29412     fail:
29413     return NULL;
29414 }
29415
29416
29417 static PyObject *_wrap_TreeCtrl_IsExpanded(PyObject *, PyObject *args, PyObject *kwargs) {
29418     PyObject *resultobj;
29419     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29420     wxTreeItemId *arg2 = 0 ;
29421     bool result;
29422     PyObject * obj0 = 0 ;
29423     PyObject * obj1 = 0 ;
29424     char *kwnames[] = {
29425         (char *) "self",(char *) "item", NULL
29426     };
29427
29428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsExpanded",kwnames,&obj0,&obj1)) goto fail;
29429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29430     if (SWIG_arg_fail(1)) SWIG_fail;
29431     {
29432         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29433         if (SWIG_arg_fail(2)) SWIG_fail;
29434         if (arg2 == NULL) {
29435             SWIG_null_ref("wxTreeItemId");
29436         }
29437         if (SWIG_arg_fail(2)) SWIG_fail;
29438     }
29439     {
29440         PyThreadState* __tstate = wxPyBeginAllowThreads();
29441         result = (bool)((wxPyTreeCtrl const *)arg1)->IsExpanded((wxTreeItemId const &)*arg2);
29442
29443         wxPyEndAllowThreads(__tstate);
29444         if (PyErr_Occurred()) SWIG_fail;
29445     }
29446     {
29447         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29448     }
29449     return resultobj;
29450     fail:
29451     return NULL;
29452 }
29453
29454
29455 static PyObject *_wrap_TreeCtrl_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
29456     PyObject *resultobj;
29457     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29458     wxTreeItemId *arg2 = 0 ;
29459     bool result;
29460     PyObject * obj0 = 0 ;
29461     PyObject * obj1 = 0 ;
29462     char *kwnames[] = {
29463         (char *) "self",(char *) "item", NULL
29464     };
29465
29466     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsSelected",kwnames,&obj0,&obj1)) goto fail;
29467     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29468     if (SWIG_arg_fail(1)) SWIG_fail;
29469     {
29470         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29471         if (SWIG_arg_fail(2)) SWIG_fail;
29472         if (arg2 == NULL) {
29473             SWIG_null_ref("wxTreeItemId");
29474         }
29475         if (SWIG_arg_fail(2)) SWIG_fail;
29476     }
29477     {
29478         PyThreadState* __tstate = wxPyBeginAllowThreads();
29479         result = (bool)((wxPyTreeCtrl const *)arg1)->IsSelected((wxTreeItemId const &)*arg2);
29480
29481         wxPyEndAllowThreads(__tstate);
29482         if (PyErr_Occurred()) SWIG_fail;
29483     }
29484     {
29485         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29486     }
29487     return resultobj;
29488     fail:
29489     return NULL;
29490 }
29491
29492
29493 static PyObject *_wrap_TreeCtrl_IsBold(PyObject *, PyObject *args, PyObject *kwargs) {
29494     PyObject *resultobj;
29495     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29496     wxTreeItemId *arg2 = 0 ;
29497     bool result;
29498     PyObject * obj0 = 0 ;
29499     PyObject * obj1 = 0 ;
29500     char *kwnames[] = {
29501         (char *) "self",(char *) "item", NULL
29502     };
29503
29504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsBold",kwnames,&obj0,&obj1)) goto fail;
29505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29506     if (SWIG_arg_fail(1)) SWIG_fail;
29507     {
29508         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29509         if (SWIG_arg_fail(2)) SWIG_fail;
29510         if (arg2 == NULL) {
29511             SWIG_null_ref("wxTreeItemId");
29512         }
29513         if (SWIG_arg_fail(2)) SWIG_fail;
29514     }
29515     {
29516         PyThreadState* __tstate = wxPyBeginAllowThreads();
29517         result = (bool)((wxPyTreeCtrl const *)arg1)->IsBold((wxTreeItemId const &)*arg2);
29518
29519         wxPyEndAllowThreads(__tstate);
29520         if (PyErr_Occurred()) SWIG_fail;
29521     }
29522     {
29523         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29524     }
29525     return resultobj;
29526     fail:
29527     return NULL;
29528 }
29529
29530
29531 static PyObject *_wrap_TreeCtrl_GetChildrenCount(PyObject *, PyObject *args, PyObject *kwargs) {
29532     PyObject *resultobj;
29533     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29534     wxTreeItemId *arg2 = 0 ;
29535     bool arg3 = (bool) true ;
29536     size_t result;
29537     PyObject * obj0 = 0 ;
29538     PyObject * obj1 = 0 ;
29539     PyObject * obj2 = 0 ;
29540     char *kwnames[] = {
29541         (char *) "self",(char *) "item",(char *) "recursively", NULL
29542     };
29543
29544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetChildrenCount",kwnames,&obj0,&obj1,&obj2)) goto fail;
29545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29546     if (SWIG_arg_fail(1)) SWIG_fail;
29547     {
29548         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29549         if (SWIG_arg_fail(2)) SWIG_fail;
29550         if (arg2 == NULL) {
29551             SWIG_null_ref("wxTreeItemId");
29552         }
29553         if (SWIG_arg_fail(2)) SWIG_fail;
29554     }
29555     if (obj2) {
29556         {
29557             arg3 = (bool)(SWIG_As_bool(obj2));
29558             if (SWIG_arg_fail(3)) SWIG_fail;
29559         }
29560     }
29561     {
29562         PyThreadState* __tstate = wxPyBeginAllowThreads();
29563         result = (size_t)(arg1)->GetChildrenCount((wxTreeItemId const &)*arg2,arg3);
29564
29565         wxPyEndAllowThreads(__tstate);
29566         if (PyErr_Occurred()) SWIG_fail;
29567     }
29568     {
29569         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
29570     }
29571     return resultobj;
29572     fail:
29573     return NULL;
29574 }
29575
29576
29577 static PyObject *_wrap_TreeCtrl_GetRootItem(PyObject *, PyObject *args, PyObject *kwargs) {
29578     PyObject *resultobj;
29579     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29580     wxTreeItemId result;
29581     PyObject * obj0 = 0 ;
29582     char *kwnames[] = {
29583         (char *) "self", NULL
29584     };
29585
29586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetRootItem",kwnames,&obj0)) goto fail;
29587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29588     if (SWIG_arg_fail(1)) SWIG_fail;
29589     {
29590         PyThreadState* __tstate = wxPyBeginAllowThreads();
29591         result = ((wxPyTreeCtrl const *)arg1)->GetRootItem();
29592
29593         wxPyEndAllowThreads(__tstate);
29594         if (PyErr_Occurred()) SWIG_fail;
29595     }
29596     {
29597         wxTreeItemId * resultptr;
29598         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29599         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29600     }
29601     return resultobj;
29602     fail:
29603     return NULL;
29604 }
29605
29606
29607 static PyObject *_wrap_TreeCtrl_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
29608     PyObject *resultobj;
29609     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29610     wxTreeItemId result;
29611     PyObject * obj0 = 0 ;
29612     char *kwnames[] = {
29613         (char *) "self", NULL
29614     };
29615
29616     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSelection",kwnames,&obj0)) goto fail;
29617     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29618     if (SWIG_arg_fail(1)) SWIG_fail;
29619     {
29620         PyThreadState* __tstate = wxPyBeginAllowThreads();
29621         result = ((wxPyTreeCtrl const *)arg1)->GetSelection();
29622
29623         wxPyEndAllowThreads(__tstate);
29624         if (PyErr_Occurred()) SWIG_fail;
29625     }
29626     {
29627         wxTreeItemId * resultptr;
29628         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29629         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29630     }
29631     return resultobj;
29632     fail:
29633     return NULL;
29634 }
29635
29636
29637 static PyObject *_wrap_TreeCtrl_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
29638     PyObject *resultobj;
29639     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29640     PyObject *result;
29641     PyObject * obj0 = 0 ;
29642     char *kwnames[] = {
29643         (char *) "self", NULL
29644     };
29645
29646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSelections",kwnames,&obj0)) goto fail;
29647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29648     if (SWIG_arg_fail(1)) SWIG_fail;
29649     {
29650         PyThreadState* __tstate = wxPyBeginAllowThreads();
29651         result = (PyObject *)wxPyTreeCtrl_GetSelections(arg1);
29652
29653         wxPyEndAllowThreads(__tstate);
29654         if (PyErr_Occurred()) SWIG_fail;
29655     }
29656     resultobj = result;
29657     return resultobj;
29658     fail:
29659     return NULL;
29660 }
29661
29662
29663 static PyObject *_wrap_TreeCtrl_GetItemParent(PyObject *, PyObject *args, PyObject *kwargs) {
29664     PyObject *resultobj;
29665     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29666     wxTreeItemId *arg2 = 0 ;
29667     wxTreeItemId result;
29668     PyObject * obj0 = 0 ;
29669     PyObject * obj1 = 0 ;
29670     char *kwnames[] = {
29671         (char *) "self",(char *) "item", NULL
29672     };
29673
29674     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemParent",kwnames,&obj0,&obj1)) goto fail;
29675     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29676     if (SWIG_arg_fail(1)) SWIG_fail;
29677     {
29678         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29679         if (SWIG_arg_fail(2)) SWIG_fail;
29680         if (arg2 == NULL) {
29681             SWIG_null_ref("wxTreeItemId");
29682         }
29683         if (SWIG_arg_fail(2)) SWIG_fail;
29684     }
29685     {
29686         PyThreadState* __tstate = wxPyBeginAllowThreads();
29687         result = ((wxPyTreeCtrl const *)arg1)->GetItemParent((wxTreeItemId const &)*arg2);
29688
29689         wxPyEndAllowThreads(__tstate);
29690         if (PyErr_Occurred()) SWIG_fail;
29691     }
29692     {
29693         wxTreeItemId * resultptr;
29694         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29695         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29696     }
29697     return resultobj;
29698     fail:
29699     return NULL;
29700 }
29701
29702
29703 static PyObject *_wrap_TreeCtrl_GetFirstChild(PyObject *, PyObject *args, PyObject *kwargs) {
29704     PyObject *resultobj;
29705     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29706     wxTreeItemId *arg2 = 0 ;
29707     PyObject *result;
29708     PyObject * obj0 = 0 ;
29709     PyObject * obj1 = 0 ;
29710     char *kwnames[] = {
29711         (char *) "self",(char *) "item", NULL
29712     };
29713
29714     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetFirstChild",kwnames,&obj0,&obj1)) goto fail;
29715     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29716     if (SWIG_arg_fail(1)) SWIG_fail;
29717     {
29718         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29719         if (SWIG_arg_fail(2)) SWIG_fail;
29720         if (arg2 == NULL) {
29721             SWIG_null_ref("wxTreeItemId");
29722         }
29723         if (SWIG_arg_fail(2)) SWIG_fail;
29724     }
29725     {
29726         PyThreadState* __tstate = wxPyBeginAllowThreads();
29727         result = (PyObject *)wxPyTreeCtrl_GetFirstChild(arg1,(wxTreeItemId const &)*arg2);
29728
29729         wxPyEndAllowThreads(__tstate);
29730         if (PyErr_Occurred()) SWIG_fail;
29731     }
29732     resultobj = result;
29733     return resultobj;
29734     fail:
29735     return NULL;
29736 }
29737
29738
29739 static PyObject *_wrap_TreeCtrl_GetNextChild(PyObject *, PyObject *args, PyObject *kwargs) {
29740     PyObject *resultobj;
29741     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29742     wxTreeItemId *arg2 = 0 ;
29743     void *arg3 = (void *) 0 ;
29744     PyObject *result;
29745     PyObject * obj0 = 0 ;
29746     PyObject * obj1 = 0 ;
29747     PyObject * obj2 = 0 ;
29748     char *kwnames[] = {
29749         (char *) "self",(char *) "item",(char *) "cookie", NULL
29750     };
29751
29752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_GetNextChild",kwnames,&obj0,&obj1,&obj2)) goto fail;
29753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29754     if (SWIG_arg_fail(1)) SWIG_fail;
29755     {
29756         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29757         if (SWIG_arg_fail(2)) SWIG_fail;
29758         if (arg2 == NULL) {
29759             SWIG_null_ref("wxTreeItemId");
29760         }
29761         if (SWIG_arg_fail(2)) SWIG_fail;
29762     }
29763     {
29764         if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) {
29765             SWIG_arg_fail(3);SWIG_fail;
29766         }
29767     }
29768     {
29769         PyThreadState* __tstate = wxPyBeginAllowThreads();
29770         result = (PyObject *)wxPyTreeCtrl_GetNextChild(arg1,(wxTreeItemId const &)*arg2,arg3);
29771
29772         wxPyEndAllowThreads(__tstate);
29773         if (PyErr_Occurred()) SWIG_fail;
29774     }
29775     resultobj = result;
29776     return resultobj;
29777     fail:
29778     return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_TreeCtrl_GetLastChild(PyObject *, PyObject *args, PyObject *kwargs) {
29783     PyObject *resultobj;
29784     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29785     wxTreeItemId *arg2 = 0 ;
29786     wxTreeItemId result;
29787     PyObject * obj0 = 0 ;
29788     PyObject * obj1 = 0 ;
29789     char *kwnames[] = {
29790         (char *) "self",(char *) "item", NULL
29791     };
29792
29793     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetLastChild",kwnames,&obj0,&obj1)) goto fail;
29794     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29795     if (SWIG_arg_fail(1)) SWIG_fail;
29796     {
29797         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29798         if (SWIG_arg_fail(2)) SWIG_fail;
29799         if (arg2 == NULL) {
29800             SWIG_null_ref("wxTreeItemId");
29801         }
29802         if (SWIG_arg_fail(2)) SWIG_fail;
29803     }
29804     {
29805         PyThreadState* __tstate = wxPyBeginAllowThreads();
29806         result = ((wxPyTreeCtrl const *)arg1)->GetLastChild((wxTreeItemId const &)*arg2);
29807
29808         wxPyEndAllowThreads(__tstate);
29809         if (PyErr_Occurred()) SWIG_fail;
29810     }
29811     {
29812         wxTreeItemId * resultptr;
29813         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29814         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29815     }
29816     return resultobj;
29817     fail:
29818     return NULL;
29819 }
29820
29821
29822 static PyObject *_wrap_TreeCtrl_GetNextSibling(PyObject *, PyObject *args, PyObject *kwargs) {
29823     PyObject *resultobj;
29824     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29825     wxTreeItemId *arg2 = 0 ;
29826     wxTreeItemId result;
29827     PyObject * obj0 = 0 ;
29828     PyObject * obj1 = 0 ;
29829     char *kwnames[] = {
29830         (char *) "self",(char *) "item", NULL
29831     };
29832
29833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextSibling",kwnames,&obj0,&obj1)) goto fail;
29834     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29835     if (SWIG_arg_fail(1)) SWIG_fail;
29836     {
29837         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29838         if (SWIG_arg_fail(2)) SWIG_fail;
29839         if (arg2 == NULL) {
29840             SWIG_null_ref("wxTreeItemId");
29841         }
29842         if (SWIG_arg_fail(2)) SWIG_fail;
29843     }
29844     {
29845         PyThreadState* __tstate = wxPyBeginAllowThreads();
29846         result = ((wxPyTreeCtrl const *)arg1)->GetNextSibling((wxTreeItemId const &)*arg2);
29847
29848         wxPyEndAllowThreads(__tstate);
29849         if (PyErr_Occurred()) SWIG_fail;
29850     }
29851     {
29852         wxTreeItemId * resultptr;
29853         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29854         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29855     }
29856     return resultobj;
29857     fail:
29858     return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_TreeCtrl_GetPrevSibling(PyObject *, PyObject *args, PyObject *kwargs) {
29863     PyObject *resultobj;
29864     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29865     wxTreeItemId *arg2 = 0 ;
29866     wxTreeItemId result;
29867     PyObject * obj0 = 0 ;
29868     PyObject * obj1 = 0 ;
29869     char *kwnames[] = {
29870         (char *) "self",(char *) "item", NULL
29871     };
29872
29873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevSibling",kwnames,&obj0,&obj1)) goto fail;
29874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29875     if (SWIG_arg_fail(1)) SWIG_fail;
29876     {
29877         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29878         if (SWIG_arg_fail(2)) SWIG_fail;
29879         if (arg2 == NULL) {
29880             SWIG_null_ref("wxTreeItemId");
29881         }
29882         if (SWIG_arg_fail(2)) SWIG_fail;
29883     }
29884     {
29885         PyThreadState* __tstate = wxPyBeginAllowThreads();
29886         result = ((wxPyTreeCtrl const *)arg1)->GetPrevSibling((wxTreeItemId const &)*arg2);
29887
29888         wxPyEndAllowThreads(__tstate);
29889         if (PyErr_Occurred()) SWIG_fail;
29890     }
29891     {
29892         wxTreeItemId * resultptr;
29893         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29894         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29895     }
29896     return resultobj;
29897     fail:
29898     return NULL;
29899 }
29900
29901
29902 static PyObject *_wrap_TreeCtrl_GetFirstVisibleItem(PyObject *, PyObject *args, PyObject *kwargs) {
29903     PyObject *resultobj;
29904     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29905     wxTreeItemId result;
29906     PyObject * obj0 = 0 ;
29907     char *kwnames[] = {
29908         (char *) "self", NULL
29909     };
29910
29911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetFirstVisibleItem",kwnames,&obj0)) goto fail;
29912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29913     if (SWIG_arg_fail(1)) SWIG_fail;
29914     {
29915         PyThreadState* __tstate = wxPyBeginAllowThreads();
29916         result = ((wxPyTreeCtrl const *)arg1)->GetFirstVisibleItem();
29917
29918         wxPyEndAllowThreads(__tstate);
29919         if (PyErr_Occurred()) SWIG_fail;
29920     }
29921     {
29922         wxTreeItemId * resultptr;
29923         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29924         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29925     }
29926     return resultobj;
29927     fail:
29928     return NULL;
29929 }
29930
29931
29932 static PyObject *_wrap_TreeCtrl_GetNextVisible(PyObject *, PyObject *args, PyObject *kwargs) {
29933     PyObject *resultobj;
29934     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29935     wxTreeItemId *arg2 = 0 ;
29936     wxTreeItemId result;
29937     PyObject * obj0 = 0 ;
29938     PyObject * obj1 = 0 ;
29939     char *kwnames[] = {
29940         (char *) "self",(char *) "item", NULL
29941     };
29942
29943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextVisible",kwnames,&obj0,&obj1)) goto fail;
29944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29945     if (SWIG_arg_fail(1)) SWIG_fail;
29946     {
29947         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29948         if (SWIG_arg_fail(2)) SWIG_fail;
29949         if (arg2 == NULL) {
29950             SWIG_null_ref("wxTreeItemId");
29951         }
29952         if (SWIG_arg_fail(2)) SWIG_fail;
29953     }
29954     {
29955         PyThreadState* __tstate = wxPyBeginAllowThreads();
29956         result = ((wxPyTreeCtrl const *)arg1)->GetNextVisible((wxTreeItemId const &)*arg2);
29957
29958         wxPyEndAllowThreads(__tstate);
29959         if (PyErr_Occurred()) SWIG_fail;
29960     }
29961     {
29962         wxTreeItemId * resultptr;
29963         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29964         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29965     }
29966     return resultobj;
29967     fail:
29968     return NULL;
29969 }
29970
29971
29972 static PyObject *_wrap_TreeCtrl_GetPrevVisible(PyObject *, PyObject *args, PyObject *kwargs) {
29973     PyObject *resultobj;
29974     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29975     wxTreeItemId *arg2 = 0 ;
29976     wxTreeItemId result;
29977     PyObject * obj0 = 0 ;
29978     PyObject * obj1 = 0 ;
29979     char *kwnames[] = {
29980         (char *) "self",(char *) "item", NULL
29981     };
29982
29983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevVisible",kwnames,&obj0,&obj1)) goto fail;
29984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29985     if (SWIG_arg_fail(1)) SWIG_fail;
29986     {
29987         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29988         if (SWIG_arg_fail(2)) SWIG_fail;
29989         if (arg2 == NULL) {
29990             SWIG_null_ref("wxTreeItemId");
29991         }
29992         if (SWIG_arg_fail(2)) SWIG_fail;
29993     }
29994     {
29995         PyThreadState* __tstate = wxPyBeginAllowThreads();
29996         result = ((wxPyTreeCtrl const *)arg1)->GetPrevVisible((wxTreeItemId const &)*arg2);
29997
29998         wxPyEndAllowThreads(__tstate);
29999         if (PyErr_Occurred()) SWIG_fail;
30000     }
30001     {
30002         wxTreeItemId * resultptr;
30003         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30004         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30005     }
30006     return resultobj;
30007     fail:
30008     return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_TreeCtrl_AddRoot(PyObject *, PyObject *args, PyObject *kwargs) {
30013     PyObject *resultobj;
30014     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30015     wxString *arg2 = 0 ;
30016     int arg3 = (int) -1 ;
30017     int arg4 = (int) -1 ;
30018     wxPyTreeItemData *arg5 = (wxPyTreeItemData *) NULL ;
30019     wxTreeItemId result;
30020     bool temp2 = false ;
30021     PyObject * obj0 = 0 ;
30022     PyObject * obj1 = 0 ;
30023     PyObject * obj2 = 0 ;
30024     PyObject * obj3 = 0 ;
30025     PyObject * obj4 = 0 ;
30026     char *kwnames[] = {
30027         (char *) "self",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30028     };
30029
30030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:TreeCtrl_AddRoot",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30031     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30032     if (SWIG_arg_fail(1)) SWIG_fail;
30033     {
30034         arg2 = wxString_in_helper(obj1);
30035         if (arg2 == NULL) SWIG_fail;
30036         temp2 = true;
30037     }
30038     if (obj2) {
30039         {
30040             arg3 = (int)(SWIG_As_int(obj2));
30041             if (SWIG_arg_fail(3)) SWIG_fail;
30042         }
30043     }
30044     if (obj3) {
30045         {
30046             arg4 = (int)(SWIG_As_int(obj3));
30047             if (SWIG_arg_fail(4)) SWIG_fail;
30048         }
30049     }
30050     if (obj4) {
30051         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30052         if (SWIG_arg_fail(5)) SWIG_fail;
30053     }
30054     {
30055         PyThreadState* __tstate = wxPyBeginAllowThreads();
30056         result = (arg1)->AddRoot((wxString const &)*arg2,arg3,arg4,arg5);
30057
30058         wxPyEndAllowThreads(__tstate);
30059         if (PyErr_Occurred()) SWIG_fail;
30060     }
30061     {
30062         wxTreeItemId * resultptr;
30063         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30064         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30065     }
30066     {
30067         if (temp2)
30068         delete arg2;
30069     }
30070     return resultobj;
30071     fail:
30072     {
30073         if (temp2)
30074         delete arg2;
30075     }
30076     return NULL;
30077 }
30078
30079
30080 static PyObject *_wrap_TreeCtrl_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
30081     PyObject *resultobj;
30082     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30083     wxTreeItemId *arg2 = 0 ;
30084     wxString *arg3 = 0 ;
30085     int arg4 = (int) -1 ;
30086     int arg5 = (int) -1 ;
30087     wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
30088     wxTreeItemId result;
30089     bool temp3 = false ;
30090     PyObject * obj0 = 0 ;
30091     PyObject * obj1 = 0 ;
30092     PyObject * obj2 = 0 ;
30093     PyObject * obj3 = 0 ;
30094     PyObject * obj4 = 0 ;
30095     PyObject * obj5 = 0 ;
30096     char *kwnames[] = {
30097         (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30098     };
30099
30100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_PrependItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30102     if (SWIG_arg_fail(1)) SWIG_fail;
30103     {
30104         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30105         if (SWIG_arg_fail(2)) SWIG_fail;
30106         if (arg2 == NULL) {
30107             SWIG_null_ref("wxTreeItemId");
30108         }
30109         if (SWIG_arg_fail(2)) SWIG_fail;
30110     }
30111     {
30112         arg3 = wxString_in_helper(obj2);
30113         if (arg3 == NULL) SWIG_fail;
30114         temp3 = true;
30115     }
30116     if (obj3) {
30117         {
30118             arg4 = (int)(SWIG_As_int(obj3));
30119             if (SWIG_arg_fail(4)) SWIG_fail;
30120         }
30121     }
30122     if (obj4) {
30123         {
30124             arg5 = (int)(SWIG_As_int(obj4));
30125             if (SWIG_arg_fail(5)) SWIG_fail;
30126         }
30127     }
30128     if (obj5) {
30129         SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30130         if (SWIG_arg_fail(6)) SWIG_fail;
30131     }
30132     {
30133         PyThreadState* __tstate = wxPyBeginAllowThreads();
30134         result = (arg1)->PrependItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
30135
30136         wxPyEndAllowThreads(__tstate);
30137         if (PyErr_Occurred()) SWIG_fail;
30138     }
30139     {
30140         wxTreeItemId * resultptr;
30141         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30142         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30143     }
30144     {
30145         if (temp3)
30146         delete arg3;
30147     }
30148     return resultobj;
30149     fail:
30150     {
30151         if (temp3)
30152         delete arg3;
30153     }
30154     return NULL;
30155 }
30156
30157
30158 static PyObject *_wrap_TreeCtrl_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
30159     PyObject *resultobj;
30160     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30161     wxTreeItemId *arg2 = 0 ;
30162     wxTreeItemId *arg3 = 0 ;
30163     wxString *arg4 = 0 ;
30164     int arg5 = (int) -1 ;
30165     int arg6 = (int) -1 ;
30166     wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
30167     wxTreeItemId result;
30168     bool temp4 = false ;
30169     PyObject * obj0 = 0 ;
30170     PyObject * obj1 = 0 ;
30171     PyObject * obj2 = 0 ;
30172     PyObject * obj3 = 0 ;
30173     PyObject * obj4 = 0 ;
30174     PyObject * obj5 = 0 ;
30175     PyObject * obj6 = 0 ;
30176     char *kwnames[] = {
30177         (char *) "self",(char *) "parent",(char *) "idPrevious",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30178     };
30179
30180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
30181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30182     if (SWIG_arg_fail(1)) SWIG_fail;
30183     {
30184         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30185         if (SWIG_arg_fail(2)) SWIG_fail;
30186         if (arg2 == NULL) {
30187             SWIG_null_ref("wxTreeItemId");
30188         }
30189         if (SWIG_arg_fail(2)) SWIG_fail;
30190     }
30191     {
30192         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30193         if (SWIG_arg_fail(3)) SWIG_fail;
30194         if (arg3 == NULL) {
30195             SWIG_null_ref("wxTreeItemId");
30196         }
30197         if (SWIG_arg_fail(3)) SWIG_fail;
30198     }
30199     {
30200         arg4 = wxString_in_helper(obj3);
30201         if (arg4 == NULL) SWIG_fail;
30202         temp4 = true;
30203     }
30204     if (obj4) {
30205         {
30206             arg5 = (int)(SWIG_As_int(obj4));
30207             if (SWIG_arg_fail(5)) SWIG_fail;
30208         }
30209     }
30210     if (obj5) {
30211         {
30212             arg6 = (int)(SWIG_As_int(obj5));
30213             if (SWIG_arg_fail(6)) SWIG_fail;
30214         }
30215     }
30216     if (obj6) {
30217         SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30218         if (SWIG_arg_fail(7)) SWIG_fail;
30219     }
30220     {
30221         PyThreadState* __tstate = wxPyBeginAllowThreads();
30222         result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,(wxTreeItemId const &)*arg3,(wxString const &)*arg4,arg5,arg6,arg7);
30223
30224         wxPyEndAllowThreads(__tstate);
30225         if (PyErr_Occurred()) SWIG_fail;
30226     }
30227     {
30228         wxTreeItemId * resultptr;
30229         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30230         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30231     }
30232     {
30233         if (temp4)
30234         delete arg4;
30235     }
30236     return resultobj;
30237     fail:
30238     {
30239         if (temp4)
30240         delete arg4;
30241     }
30242     return NULL;
30243 }
30244
30245
30246 static PyObject *_wrap_TreeCtrl_InsertItemBefore(PyObject *, PyObject *args, PyObject *kwargs) {
30247     PyObject *resultobj;
30248     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30249     wxTreeItemId *arg2 = 0 ;
30250     size_t arg3 ;
30251     wxString *arg4 = 0 ;
30252     int arg5 = (int) -1 ;
30253     int arg6 = (int) -1 ;
30254     wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
30255     wxTreeItemId result;
30256     bool temp4 = false ;
30257     PyObject * obj0 = 0 ;
30258     PyObject * obj1 = 0 ;
30259     PyObject * obj2 = 0 ;
30260     PyObject * obj3 = 0 ;
30261     PyObject * obj4 = 0 ;
30262     PyObject * obj5 = 0 ;
30263     PyObject * obj6 = 0 ;
30264     char *kwnames[] = {
30265         (char *) "self",(char *) "parent",(char *) "index",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30266     };
30267
30268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItemBefore",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
30269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30270     if (SWIG_arg_fail(1)) SWIG_fail;
30271     {
30272         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30273         if (SWIG_arg_fail(2)) SWIG_fail;
30274         if (arg2 == NULL) {
30275             SWIG_null_ref("wxTreeItemId");
30276         }
30277         if (SWIG_arg_fail(2)) SWIG_fail;
30278     }
30279     {
30280         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
30281         if (SWIG_arg_fail(3)) SWIG_fail;
30282     }
30283     {
30284         arg4 = wxString_in_helper(obj3);
30285         if (arg4 == NULL) SWIG_fail;
30286         temp4 = true;
30287     }
30288     if (obj4) {
30289         {
30290             arg5 = (int)(SWIG_As_int(obj4));
30291             if (SWIG_arg_fail(5)) SWIG_fail;
30292         }
30293     }
30294     if (obj5) {
30295         {
30296             arg6 = (int)(SWIG_As_int(obj5));
30297             if (SWIG_arg_fail(6)) SWIG_fail;
30298         }
30299     }
30300     if (obj6) {
30301         SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30302         if (SWIG_arg_fail(7)) SWIG_fail;
30303     }
30304     {
30305         PyThreadState* __tstate = wxPyBeginAllowThreads();
30306         result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,arg3,(wxString const &)*arg4,arg5,arg6,arg7);
30307
30308         wxPyEndAllowThreads(__tstate);
30309         if (PyErr_Occurred()) SWIG_fail;
30310     }
30311     {
30312         wxTreeItemId * resultptr;
30313         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30314         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30315     }
30316     {
30317         if (temp4)
30318         delete arg4;
30319     }
30320     return resultobj;
30321     fail:
30322     {
30323         if (temp4)
30324         delete arg4;
30325     }
30326     return NULL;
30327 }
30328
30329
30330 static PyObject *_wrap_TreeCtrl_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
30331     PyObject *resultobj;
30332     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30333     wxTreeItemId *arg2 = 0 ;
30334     wxString *arg3 = 0 ;
30335     int arg4 = (int) -1 ;
30336     int arg5 = (int) -1 ;
30337     wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
30338     wxTreeItemId result;
30339     bool temp3 = false ;
30340     PyObject * obj0 = 0 ;
30341     PyObject * obj1 = 0 ;
30342     PyObject * obj2 = 0 ;
30343     PyObject * obj3 = 0 ;
30344     PyObject * obj4 = 0 ;
30345     PyObject * obj5 = 0 ;
30346     char *kwnames[] = {
30347         (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30348     };
30349
30350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_AppendItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30351     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30352     if (SWIG_arg_fail(1)) SWIG_fail;
30353     {
30354         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30355         if (SWIG_arg_fail(2)) SWIG_fail;
30356         if (arg2 == NULL) {
30357             SWIG_null_ref("wxTreeItemId");
30358         }
30359         if (SWIG_arg_fail(2)) SWIG_fail;
30360     }
30361     {
30362         arg3 = wxString_in_helper(obj2);
30363         if (arg3 == NULL) SWIG_fail;
30364         temp3 = true;
30365     }
30366     if (obj3) {
30367         {
30368             arg4 = (int)(SWIG_As_int(obj3));
30369             if (SWIG_arg_fail(4)) SWIG_fail;
30370         }
30371     }
30372     if (obj4) {
30373         {
30374             arg5 = (int)(SWIG_As_int(obj4));
30375             if (SWIG_arg_fail(5)) SWIG_fail;
30376         }
30377     }
30378     if (obj5) {
30379         SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30380         if (SWIG_arg_fail(6)) SWIG_fail;
30381     }
30382     {
30383         PyThreadState* __tstate = wxPyBeginAllowThreads();
30384         result = (arg1)->AppendItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
30385
30386         wxPyEndAllowThreads(__tstate);
30387         if (PyErr_Occurred()) SWIG_fail;
30388     }
30389     {
30390         wxTreeItemId * resultptr;
30391         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30392         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30393     }
30394     {
30395         if (temp3)
30396         delete arg3;
30397     }
30398     return resultobj;
30399     fail:
30400     {
30401         if (temp3)
30402         delete arg3;
30403     }
30404     return NULL;
30405 }
30406
30407
30408 static PyObject *_wrap_TreeCtrl_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
30409     PyObject *resultobj;
30410     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30411     wxTreeItemId *arg2 = 0 ;
30412     PyObject * obj0 = 0 ;
30413     PyObject * obj1 = 0 ;
30414     char *kwnames[] = {
30415         (char *) "self",(char *) "item", NULL
30416     };
30417
30418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Delete",kwnames,&obj0,&obj1)) goto fail;
30419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30420     if (SWIG_arg_fail(1)) SWIG_fail;
30421     {
30422         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30423         if (SWIG_arg_fail(2)) SWIG_fail;
30424         if (arg2 == NULL) {
30425             SWIG_null_ref("wxTreeItemId");
30426         }
30427         if (SWIG_arg_fail(2)) SWIG_fail;
30428     }
30429     {
30430         PyThreadState* __tstate = wxPyBeginAllowThreads();
30431         (arg1)->Delete((wxTreeItemId const &)*arg2);
30432
30433         wxPyEndAllowThreads(__tstate);
30434         if (PyErr_Occurred()) SWIG_fail;
30435     }
30436     Py_INCREF(Py_None); resultobj = Py_None;
30437     return resultobj;
30438     fail:
30439     return NULL;
30440 }
30441
30442
30443 static PyObject *_wrap_TreeCtrl_DeleteChildren(PyObject *, PyObject *args, PyObject *kwargs) {
30444     PyObject *resultobj;
30445     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30446     wxTreeItemId *arg2 = 0 ;
30447     PyObject * obj0 = 0 ;
30448     PyObject * obj1 = 0 ;
30449     char *kwnames[] = {
30450         (char *) "self",(char *) "item", NULL
30451     };
30452
30453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_DeleteChildren",kwnames,&obj0,&obj1)) goto fail;
30454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30455     if (SWIG_arg_fail(1)) SWIG_fail;
30456     {
30457         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30458         if (SWIG_arg_fail(2)) SWIG_fail;
30459         if (arg2 == NULL) {
30460             SWIG_null_ref("wxTreeItemId");
30461         }
30462         if (SWIG_arg_fail(2)) SWIG_fail;
30463     }
30464     {
30465         PyThreadState* __tstate = wxPyBeginAllowThreads();
30466         (arg1)->DeleteChildren((wxTreeItemId const &)*arg2);
30467
30468         wxPyEndAllowThreads(__tstate);
30469         if (PyErr_Occurred()) SWIG_fail;
30470     }
30471     Py_INCREF(Py_None); resultobj = Py_None;
30472     return resultobj;
30473     fail:
30474     return NULL;
30475 }
30476
30477
30478 static PyObject *_wrap_TreeCtrl_DeleteAllItems(PyObject *, PyObject *args, PyObject *kwargs) {
30479     PyObject *resultobj;
30480     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30481     PyObject * obj0 = 0 ;
30482     char *kwnames[] = {
30483         (char *) "self", NULL
30484     };
30485
30486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_DeleteAllItems",kwnames,&obj0)) goto fail;
30487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30488     if (SWIG_arg_fail(1)) SWIG_fail;
30489     {
30490         PyThreadState* __tstate = wxPyBeginAllowThreads();
30491         (arg1)->DeleteAllItems();
30492
30493         wxPyEndAllowThreads(__tstate);
30494         if (PyErr_Occurred()) SWIG_fail;
30495     }
30496     Py_INCREF(Py_None); resultobj = Py_None;
30497     return resultobj;
30498     fail:
30499     return NULL;
30500 }
30501
30502
30503 static PyObject *_wrap_TreeCtrl_Expand(PyObject *, PyObject *args, PyObject *kwargs) {
30504     PyObject *resultobj;
30505     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30506     wxTreeItemId *arg2 = 0 ;
30507     PyObject * obj0 = 0 ;
30508     PyObject * obj1 = 0 ;
30509     char *kwnames[] = {
30510         (char *) "self",(char *) "item", NULL
30511     };
30512
30513     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Expand",kwnames,&obj0,&obj1)) goto fail;
30514     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30515     if (SWIG_arg_fail(1)) SWIG_fail;
30516     {
30517         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30518         if (SWIG_arg_fail(2)) SWIG_fail;
30519         if (arg2 == NULL) {
30520             SWIG_null_ref("wxTreeItemId");
30521         }
30522         if (SWIG_arg_fail(2)) SWIG_fail;
30523     }
30524     {
30525         PyThreadState* __tstate = wxPyBeginAllowThreads();
30526         (arg1)->Expand((wxTreeItemId const &)*arg2);
30527
30528         wxPyEndAllowThreads(__tstate);
30529         if (PyErr_Occurred()) SWIG_fail;
30530     }
30531     Py_INCREF(Py_None); resultobj = Py_None;
30532     return resultobj;
30533     fail:
30534     return NULL;
30535 }
30536
30537
30538 static PyObject *_wrap_TreeCtrl_Collapse(PyObject *, PyObject *args, PyObject *kwargs) {
30539     PyObject *resultobj;
30540     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30541     wxTreeItemId *arg2 = 0 ;
30542     PyObject * obj0 = 0 ;
30543     PyObject * obj1 = 0 ;
30544     char *kwnames[] = {
30545         (char *) "self",(char *) "item", NULL
30546     };
30547
30548     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Collapse",kwnames,&obj0,&obj1)) goto fail;
30549     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30550     if (SWIG_arg_fail(1)) SWIG_fail;
30551     {
30552         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30553         if (SWIG_arg_fail(2)) SWIG_fail;
30554         if (arg2 == NULL) {
30555             SWIG_null_ref("wxTreeItemId");
30556         }
30557         if (SWIG_arg_fail(2)) SWIG_fail;
30558     }
30559     {
30560         PyThreadState* __tstate = wxPyBeginAllowThreads();
30561         (arg1)->Collapse((wxTreeItemId const &)*arg2);
30562
30563         wxPyEndAllowThreads(__tstate);
30564         if (PyErr_Occurred()) SWIG_fail;
30565     }
30566     Py_INCREF(Py_None); resultobj = Py_None;
30567     return resultobj;
30568     fail:
30569     return NULL;
30570 }
30571
30572
30573 static PyObject *_wrap_TreeCtrl_CollapseAndReset(PyObject *, PyObject *args, PyObject *kwargs) {
30574     PyObject *resultobj;
30575     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30576     wxTreeItemId *arg2 = 0 ;
30577     PyObject * obj0 = 0 ;
30578     PyObject * obj1 = 0 ;
30579     char *kwnames[] = {
30580         (char *) "self",(char *) "item", NULL
30581     };
30582
30583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_CollapseAndReset",kwnames,&obj0,&obj1)) goto fail;
30584     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30585     if (SWIG_arg_fail(1)) SWIG_fail;
30586     {
30587         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30588         if (SWIG_arg_fail(2)) SWIG_fail;
30589         if (arg2 == NULL) {
30590             SWIG_null_ref("wxTreeItemId");
30591         }
30592         if (SWIG_arg_fail(2)) SWIG_fail;
30593     }
30594     {
30595         PyThreadState* __tstate = wxPyBeginAllowThreads();
30596         (arg1)->CollapseAndReset((wxTreeItemId const &)*arg2);
30597
30598         wxPyEndAllowThreads(__tstate);
30599         if (PyErr_Occurred()) SWIG_fail;
30600     }
30601     Py_INCREF(Py_None); resultobj = Py_None;
30602     return resultobj;
30603     fail:
30604     return NULL;
30605 }
30606
30607
30608 static PyObject *_wrap_TreeCtrl_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
30609     PyObject *resultobj;
30610     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30611     wxTreeItemId *arg2 = 0 ;
30612     PyObject * obj0 = 0 ;
30613     PyObject * obj1 = 0 ;
30614     char *kwnames[] = {
30615         (char *) "self",(char *) "item", NULL
30616     };
30617
30618     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Toggle",kwnames,&obj0,&obj1)) goto fail;
30619     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30620     if (SWIG_arg_fail(1)) SWIG_fail;
30621     {
30622         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30623         if (SWIG_arg_fail(2)) SWIG_fail;
30624         if (arg2 == NULL) {
30625             SWIG_null_ref("wxTreeItemId");
30626         }
30627         if (SWIG_arg_fail(2)) SWIG_fail;
30628     }
30629     {
30630         PyThreadState* __tstate = wxPyBeginAllowThreads();
30631         (arg1)->Toggle((wxTreeItemId const &)*arg2);
30632
30633         wxPyEndAllowThreads(__tstate);
30634         if (PyErr_Occurred()) SWIG_fail;
30635     }
30636     Py_INCREF(Py_None); resultobj = Py_None;
30637     return resultobj;
30638     fail:
30639     return NULL;
30640 }
30641
30642
30643 static PyObject *_wrap_TreeCtrl_Unselect(PyObject *, PyObject *args, PyObject *kwargs) {
30644     PyObject *resultobj;
30645     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30646     PyObject * obj0 = 0 ;
30647     char *kwnames[] = {
30648         (char *) "self", NULL
30649     };
30650
30651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_Unselect",kwnames,&obj0)) goto fail;
30652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30653     if (SWIG_arg_fail(1)) SWIG_fail;
30654     {
30655         PyThreadState* __tstate = wxPyBeginAllowThreads();
30656         (arg1)->Unselect();
30657
30658         wxPyEndAllowThreads(__tstate);
30659         if (PyErr_Occurred()) SWIG_fail;
30660     }
30661     Py_INCREF(Py_None); resultobj = Py_None;
30662     return resultobj;
30663     fail:
30664     return NULL;
30665 }
30666
30667
30668 static PyObject *_wrap_TreeCtrl_UnselectItem(PyObject *, PyObject *args, PyObject *kwargs) {
30669     PyObject *resultobj;
30670     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30671     wxTreeItemId *arg2 = 0 ;
30672     PyObject * obj0 = 0 ;
30673     PyObject * obj1 = 0 ;
30674     char *kwnames[] = {
30675         (char *) "self",(char *) "item", NULL
30676     };
30677
30678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_UnselectItem",kwnames,&obj0,&obj1)) goto fail;
30679     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30680     if (SWIG_arg_fail(1)) SWIG_fail;
30681     {
30682         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30683         if (SWIG_arg_fail(2)) SWIG_fail;
30684         if (arg2 == NULL) {
30685             SWIG_null_ref("wxTreeItemId");
30686         }
30687         if (SWIG_arg_fail(2)) SWIG_fail;
30688     }
30689     {
30690         PyThreadState* __tstate = wxPyBeginAllowThreads();
30691         (arg1)->UnselectItem((wxTreeItemId const &)*arg2);
30692
30693         wxPyEndAllowThreads(__tstate);
30694         if (PyErr_Occurred()) SWIG_fail;
30695     }
30696     Py_INCREF(Py_None); resultobj = Py_None;
30697     return resultobj;
30698     fail:
30699     return NULL;
30700 }
30701
30702
30703 static PyObject *_wrap_TreeCtrl_UnselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
30704     PyObject *resultobj;
30705     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30706     PyObject * obj0 = 0 ;
30707     char *kwnames[] = {
30708         (char *) "self", NULL
30709     };
30710
30711     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_UnselectAll",kwnames,&obj0)) goto fail;
30712     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30713     if (SWIG_arg_fail(1)) SWIG_fail;
30714     {
30715         PyThreadState* __tstate = wxPyBeginAllowThreads();
30716         (arg1)->UnselectAll();
30717
30718         wxPyEndAllowThreads(__tstate);
30719         if (PyErr_Occurred()) SWIG_fail;
30720     }
30721     Py_INCREF(Py_None); resultobj = Py_None;
30722     return resultobj;
30723     fail:
30724     return NULL;
30725 }
30726
30727
30728 static PyObject *_wrap_TreeCtrl_SelectItem(PyObject *, PyObject *args, PyObject *kwargs) {
30729     PyObject *resultobj;
30730     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30731     wxTreeItemId *arg2 = 0 ;
30732     bool arg3 = (bool) true ;
30733     PyObject * obj0 = 0 ;
30734     PyObject * obj1 = 0 ;
30735     PyObject * obj2 = 0 ;
30736     char *kwnames[] = {
30737         (char *) "self",(char *) "item",(char *) "select", NULL
30738     };
30739
30740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SelectItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
30741     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30742     if (SWIG_arg_fail(1)) SWIG_fail;
30743     {
30744         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30745         if (SWIG_arg_fail(2)) SWIG_fail;
30746         if (arg2 == NULL) {
30747             SWIG_null_ref("wxTreeItemId");
30748         }
30749         if (SWIG_arg_fail(2)) SWIG_fail;
30750     }
30751     if (obj2) {
30752         {
30753             arg3 = (bool)(SWIG_As_bool(obj2));
30754             if (SWIG_arg_fail(3)) SWIG_fail;
30755         }
30756     }
30757     {
30758         PyThreadState* __tstate = wxPyBeginAllowThreads();
30759         (arg1)->SelectItem((wxTreeItemId const &)*arg2,arg3);
30760
30761         wxPyEndAllowThreads(__tstate);
30762         if (PyErr_Occurred()) SWIG_fail;
30763     }
30764     Py_INCREF(Py_None); resultobj = Py_None;
30765     return resultobj;
30766     fail:
30767     return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_TreeCtrl_ToggleItemSelection(PyObject *, PyObject *args, PyObject *kwargs) {
30772     PyObject *resultobj;
30773     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30774     wxTreeItemId *arg2 = 0 ;
30775     PyObject * obj0 = 0 ;
30776     PyObject * obj1 = 0 ;
30777     char *kwnames[] = {
30778         (char *) "self",(char *) "item", NULL
30779     };
30780
30781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ToggleItemSelection",kwnames,&obj0,&obj1)) goto fail;
30782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30783     if (SWIG_arg_fail(1)) SWIG_fail;
30784     {
30785         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30786         if (SWIG_arg_fail(2)) SWIG_fail;
30787         if (arg2 == NULL) {
30788             SWIG_null_ref("wxTreeItemId");
30789         }
30790         if (SWIG_arg_fail(2)) SWIG_fail;
30791     }
30792     {
30793         PyThreadState* __tstate = wxPyBeginAllowThreads();
30794         (arg1)->ToggleItemSelection((wxTreeItemId const &)*arg2);
30795
30796         wxPyEndAllowThreads(__tstate);
30797         if (PyErr_Occurred()) SWIG_fail;
30798     }
30799     Py_INCREF(Py_None); resultobj = Py_None;
30800     return resultobj;
30801     fail:
30802     return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_TreeCtrl_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
30807     PyObject *resultobj;
30808     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30809     wxTreeItemId *arg2 = 0 ;
30810     PyObject * obj0 = 0 ;
30811     PyObject * obj1 = 0 ;
30812     char *kwnames[] = {
30813         (char *) "self",(char *) "item", NULL
30814     };
30815
30816     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
30817     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30818     if (SWIG_arg_fail(1)) SWIG_fail;
30819     {
30820         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30821         if (SWIG_arg_fail(2)) SWIG_fail;
30822         if (arg2 == NULL) {
30823             SWIG_null_ref("wxTreeItemId");
30824         }
30825         if (SWIG_arg_fail(2)) SWIG_fail;
30826     }
30827     {
30828         PyThreadState* __tstate = wxPyBeginAllowThreads();
30829         (arg1)->EnsureVisible((wxTreeItemId const &)*arg2);
30830
30831         wxPyEndAllowThreads(__tstate);
30832         if (PyErr_Occurred()) SWIG_fail;
30833     }
30834     Py_INCREF(Py_None); resultobj = Py_None;
30835     return resultobj;
30836     fail:
30837     return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_TreeCtrl_ScrollTo(PyObject *, PyObject *args, PyObject *kwargs) {
30842     PyObject *resultobj;
30843     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30844     wxTreeItemId *arg2 = 0 ;
30845     PyObject * obj0 = 0 ;
30846     PyObject * obj1 = 0 ;
30847     char *kwnames[] = {
30848         (char *) "self",(char *) "item", NULL
30849     };
30850
30851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ScrollTo",kwnames,&obj0,&obj1)) goto fail;
30852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30853     if (SWIG_arg_fail(1)) SWIG_fail;
30854     {
30855         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30856         if (SWIG_arg_fail(2)) SWIG_fail;
30857         if (arg2 == NULL) {
30858             SWIG_null_ref("wxTreeItemId");
30859         }
30860         if (SWIG_arg_fail(2)) SWIG_fail;
30861     }
30862     {
30863         PyThreadState* __tstate = wxPyBeginAllowThreads();
30864         (arg1)->ScrollTo((wxTreeItemId const &)*arg2);
30865
30866         wxPyEndAllowThreads(__tstate);
30867         if (PyErr_Occurred()) SWIG_fail;
30868     }
30869     Py_INCREF(Py_None); resultobj = Py_None;
30870     return resultobj;
30871     fail:
30872     return NULL;
30873 }
30874
30875
30876 static PyObject *_wrap_TreeCtrl_EditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
30877     PyObject *resultobj;
30878     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30879     wxTreeItemId *arg2 = 0 ;
30880     PyObject * obj0 = 0 ;
30881     PyObject * obj1 = 0 ;
30882     char *kwnames[] = {
30883         (char *) "self",(char *) "item", NULL
30884     };
30885
30886     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EditLabel",kwnames,&obj0,&obj1)) goto fail;
30887     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30888     if (SWIG_arg_fail(1)) SWIG_fail;
30889     {
30890         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30891         if (SWIG_arg_fail(2)) SWIG_fail;
30892         if (arg2 == NULL) {
30893             SWIG_null_ref("wxTreeItemId");
30894         }
30895         if (SWIG_arg_fail(2)) SWIG_fail;
30896     }
30897     {
30898         PyThreadState* __tstate = wxPyBeginAllowThreads();
30899         (arg1)->EditLabel((wxTreeItemId const &)*arg2);
30900
30901         wxPyEndAllowThreads(__tstate);
30902         if (PyErr_Occurred()) SWIG_fail;
30903     }
30904     Py_INCREF(Py_None); resultobj = Py_None;
30905     return resultobj;
30906     fail:
30907     return NULL;
30908 }
30909
30910
30911 static PyObject *_wrap_TreeCtrl_GetEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
30912     PyObject *resultobj;
30913     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30914     wxTextCtrl *result;
30915     PyObject * obj0 = 0 ;
30916     char *kwnames[] = {
30917         (char *) "self", NULL
30918     };
30919
30920     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetEditControl",kwnames,&obj0)) goto fail;
30921     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30922     if (SWIG_arg_fail(1)) SWIG_fail;
30923     {
30924         PyThreadState* __tstate = wxPyBeginAllowThreads();
30925         result = (wxTextCtrl *)((wxPyTreeCtrl const *)arg1)->GetEditControl();
30926
30927         wxPyEndAllowThreads(__tstate);
30928         if (PyErr_Occurred()) SWIG_fail;
30929     }
30930     {
30931         resultobj = wxPyMake_wxObject(result, 0);
30932     }
30933     return resultobj;
30934     fail:
30935     return NULL;
30936 }
30937
30938
30939 static PyObject *_wrap_TreeCtrl_EndEditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
30940     PyObject *resultobj;
30941     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30942     wxTreeItemId *arg2 = 0 ;
30943     bool arg3 = (bool) false ;
30944     PyObject * obj0 = 0 ;
30945     PyObject * obj1 = 0 ;
30946     PyObject * obj2 = 0 ;
30947     char *kwnames[] = {
30948         (char *) "self",(char *) "item",(char *) "discardChanges", NULL
30949     };
30950
30951     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_EndEditLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
30952     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30953     if (SWIG_arg_fail(1)) SWIG_fail;
30954     {
30955         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30956         if (SWIG_arg_fail(2)) SWIG_fail;
30957         if (arg2 == NULL) {
30958             SWIG_null_ref("wxTreeItemId");
30959         }
30960         if (SWIG_arg_fail(2)) SWIG_fail;
30961     }
30962     if (obj2) {
30963         {
30964             arg3 = (bool)(SWIG_As_bool(obj2));
30965             if (SWIG_arg_fail(3)) SWIG_fail;
30966         }
30967     }
30968     {
30969         PyThreadState* __tstate = wxPyBeginAllowThreads();
30970         (arg1)->EndEditLabel((wxTreeItemId const &)*arg2,arg3);
30971
30972         wxPyEndAllowThreads(__tstate);
30973         if (PyErr_Occurred()) SWIG_fail;
30974     }
30975     Py_INCREF(Py_None); resultobj = Py_None;
30976     return resultobj;
30977     fail:
30978     return NULL;
30979 }
30980
30981
30982 static PyObject *_wrap_TreeCtrl_SortChildren(PyObject *, PyObject *args, PyObject *kwargs) {
30983     PyObject *resultobj;
30984     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30985     wxTreeItemId *arg2 = 0 ;
30986     PyObject * obj0 = 0 ;
30987     PyObject * obj1 = 0 ;
30988     char *kwnames[] = {
30989         (char *) "self",(char *) "item", NULL
30990     };
30991
30992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SortChildren",kwnames,&obj0,&obj1)) goto fail;
30993     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30994     if (SWIG_arg_fail(1)) SWIG_fail;
30995     {
30996         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30997         if (SWIG_arg_fail(2)) SWIG_fail;
30998         if (arg2 == NULL) {
30999             SWIG_null_ref("wxTreeItemId");
31000         }
31001         if (SWIG_arg_fail(2)) SWIG_fail;
31002     }
31003     {
31004         PyThreadState* __tstate = wxPyBeginAllowThreads();
31005         (arg1)->SortChildren((wxTreeItemId const &)*arg2);
31006
31007         wxPyEndAllowThreads(__tstate);
31008         if (PyErr_Occurred()) SWIG_fail;
31009     }
31010     Py_INCREF(Py_None); resultobj = Py_None;
31011     return resultobj;
31012     fail:
31013     return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_TreeCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31018     PyObject *resultobj;
31019     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31020     wxPoint *arg2 = 0 ;
31021     int *arg3 = 0 ;
31022     wxTreeItemId result;
31023     wxPoint temp2 ;
31024     int temp3 ;
31025     int res3 = 0 ;
31026     PyObject * obj0 = 0 ;
31027     PyObject * obj1 = 0 ;
31028     char *kwnames[] = {
31029         (char *) "self",(char *) "point", NULL
31030     };
31031
31032     arg3 = &temp3; res3 = SWIG_NEWOBJ;
31033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
31034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31035     if (SWIG_arg_fail(1)) SWIG_fail;
31036     {
31037         arg2 = &temp2;
31038         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31039     }
31040     {
31041         PyThreadState* __tstate = wxPyBeginAllowThreads();
31042         result = (arg1)->HitTest((wxPoint const &)*arg2,*arg3);
31043
31044         wxPyEndAllowThreads(__tstate);
31045         if (PyErr_Occurred()) SWIG_fail;
31046     }
31047     {
31048         wxTreeItemId * resultptr;
31049         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
31050         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
31051     }
31052     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31053     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31054     return resultobj;
31055     fail:
31056     return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_TreeCtrl_GetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
31061     PyObject *resultobj;
31062     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31063     wxTreeItemId *arg2 = 0 ;
31064     bool arg3 = (bool) false ;
31065     PyObject *result;
31066     PyObject * obj0 = 0 ;
31067     PyObject * obj1 = 0 ;
31068     PyObject * obj2 = 0 ;
31069     char *kwnames[] = {
31070         (char *) "self",(char *) "item",(char *) "textOnly", NULL
31071     };
31072
31073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetBoundingRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
31074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31075     if (SWIG_arg_fail(1)) SWIG_fail;
31076     {
31077         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31078         if (SWIG_arg_fail(2)) SWIG_fail;
31079         if (arg2 == NULL) {
31080             SWIG_null_ref("wxTreeItemId");
31081         }
31082         if (SWIG_arg_fail(2)) SWIG_fail;
31083     }
31084     if (obj2) {
31085         {
31086             arg3 = (bool)(SWIG_As_bool(obj2));
31087             if (SWIG_arg_fail(3)) SWIG_fail;
31088         }
31089     }
31090     {
31091         PyThreadState* __tstate = wxPyBeginAllowThreads();
31092         result = (PyObject *)wxPyTreeCtrl_GetBoundingRect(arg1,(wxTreeItemId const &)*arg2,arg3);
31093
31094         wxPyEndAllowThreads(__tstate);
31095         if (PyErr_Occurred()) SWIG_fail;
31096     }
31097     resultobj = result;
31098     return resultobj;
31099     fail:
31100     return NULL;
31101 }
31102
31103
31104 static PyObject *_wrap_TreeCtrl_SetState(PyObject *, PyObject *args, PyObject *kwargs) {
31105     PyObject *resultobj;
31106     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31107     wxTreeItemId *arg2 = 0 ;
31108     int arg3 ;
31109     PyObject * obj0 = 0 ;
31110     PyObject * obj1 = 0 ;
31111     PyObject * obj2 = 0 ;
31112     char *kwnames[] = {
31113         (char *) "self",(char *) "node",(char *) "state", NULL
31114     };
31115
31116     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetState",kwnames,&obj0,&obj1,&obj2)) goto fail;
31117     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31118     if (SWIG_arg_fail(1)) SWIG_fail;
31119     {
31120         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31121         if (SWIG_arg_fail(2)) SWIG_fail;
31122         if (arg2 == NULL) {
31123             SWIG_null_ref("wxTreeItemId");
31124         }
31125         if (SWIG_arg_fail(2)) SWIG_fail;
31126     }
31127     {
31128         arg3 = (int)(SWIG_As_int(obj2));
31129         if (SWIG_arg_fail(3)) SWIG_fail;
31130     }
31131     {
31132         PyThreadState* __tstate = wxPyBeginAllowThreads();
31133         (arg1)->SetState((wxTreeItemId const &)*arg2,arg3);
31134
31135         wxPyEndAllowThreads(__tstate);
31136         if (PyErr_Occurred()) SWIG_fail;
31137     }
31138     Py_INCREF(Py_None); resultobj = Py_None;
31139     return resultobj;
31140     fail:
31141     return NULL;
31142 }
31143
31144
31145 static PyObject *_wrap_TreeCtrl_GetState(PyObject *, PyObject *args, PyObject *kwargs) {
31146     PyObject *resultobj;
31147     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31148     wxTreeItemId *arg2 = 0 ;
31149     int result;
31150     PyObject * obj0 = 0 ;
31151     PyObject * obj1 = 0 ;
31152     char *kwnames[] = {
31153         (char *) "self",(char *) "node", NULL
31154     };
31155
31156     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetState",kwnames,&obj0,&obj1)) goto fail;
31157     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31158     if (SWIG_arg_fail(1)) SWIG_fail;
31159     {
31160         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31161         if (SWIG_arg_fail(2)) SWIG_fail;
31162         if (arg2 == NULL) {
31163             SWIG_null_ref("wxTreeItemId");
31164         }
31165         if (SWIG_arg_fail(2)) SWIG_fail;
31166     }
31167     {
31168         PyThreadState* __tstate = wxPyBeginAllowThreads();
31169         result = (int)(arg1)->GetState((wxTreeItemId const &)*arg2);
31170
31171         wxPyEndAllowThreads(__tstate);
31172         if (PyErr_Occurred()) SWIG_fail;
31173     }
31174     {
31175         resultobj = SWIG_From_int((int)(result));
31176     }
31177     return resultobj;
31178     fail:
31179     return NULL;
31180 }
31181
31182
31183 static PyObject *_wrap_TreeCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31184     PyObject *resultobj;
31185     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
31186     wxVisualAttributes result;
31187     PyObject * obj0 = 0 ;
31188     char *kwnames[] = {
31189         (char *) "variant", NULL
31190     };
31191
31192     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TreeCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
31193     if (obj0) {
31194         {
31195             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
31196             if (SWIG_arg_fail(1)) SWIG_fail;
31197         }
31198     }
31199     {
31200         if (!wxPyCheckForApp()) SWIG_fail;
31201         PyThreadState* __tstate = wxPyBeginAllowThreads();
31202         result = wxPyTreeCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
31203
31204         wxPyEndAllowThreads(__tstate);
31205         if (PyErr_Occurred()) SWIG_fail;
31206     }
31207     {
31208         wxVisualAttributes * resultptr;
31209         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
31210         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
31211     }
31212     return resultobj;
31213     fail:
31214     return NULL;
31215 }
31216
31217
31218 static PyObject * TreeCtrl_swigregister(PyObject *, PyObject *args) {
31219     PyObject *obj;
31220     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31221     SWIG_TypeClientData(SWIGTYPE_p_wxPyTreeCtrl, obj);
31222     Py_INCREF(obj);
31223     return Py_BuildValue((char *)"");
31224 }
31225 static int _wrap_DirDialogDefaultFolderStr_set(PyObject *) {
31226     PyErr_SetString(PyExc_TypeError,"Variable DirDialogDefaultFolderStr is read-only.");
31227     return 1;
31228 }
31229
31230
31231 static PyObject *_wrap_DirDialogDefaultFolderStr_get(void) {
31232     PyObject *pyobj;
31233
31234     {
31235 #if wxUSE_UNICODE
31236         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
31237 #else
31238         pyobj = PyString_FromStringAndSize((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
31239 #endif
31240     }
31241     return pyobj;
31242 }
31243
31244
31245 static PyObject *_wrap_new_GenericDirCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
31246     PyObject *resultobj;
31247     wxWindow *arg1 = (wxWindow *) 0 ;
31248     int arg2 = (int) (int)-1 ;
31249     wxString const &arg3_defvalue = wxPyDirDialogDefaultFolderStr ;
31250     wxString *arg3 = (wxString *) &arg3_defvalue ;
31251     wxPoint const &arg4_defvalue = wxDefaultPosition ;
31252     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
31253     wxSize const &arg5_defvalue = wxDefaultSize ;
31254     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
31255     long arg6 = (long) wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER ;
31256     wxString const &arg7_defvalue = wxPyEmptyString ;
31257     wxString *arg7 = (wxString *) &arg7_defvalue ;
31258     int arg8 = (int) 0 ;
31259     wxString const &arg9_defvalue = wxPyTreeCtrlNameStr ;
31260     wxString *arg9 = (wxString *) &arg9_defvalue ;
31261     wxGenericDirCtrl *result;
31262     bool temp3 = false ;
31263     wxPoint temp4 ;
31264     wxSize temp5 ;
31265     bool temp7 = false ;
31266     bool temp9 = false ;
31267     PyObject * obj0 = 0 ;
31268     PyObject * obj1 = 0 ;
31269     PyObject * obj2 = 0 ;
31270     PyObject * obj3 = 0 ;
31271     PyObject * obj4 = 0 ;
31272     PyObject * obj5 = 0 ;
31273     PyObject * obj6 = 0 ;
31274     PyObject * obj7 = 0 ;
31275     PyObject * obj8 = 0 ;
31276     char *kwnames[] = {
31277         (char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL
31278     };
31279
31280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_GenericDirCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
31281     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31282     if (SWIG_arg_fail(1)) SWIG_fail;
31283     if (obj1) {
31284         {
31285             arg2 = (int const)(SWIG_As_int(obj1));
31286             if (SWIG_arg_fail(2)) SWIG_fail;
31287         }
31288     }
31289     if (obj2) {
31290         {
31291             arg3 = wxString_in_helper(obj2);
31292             if (arg3 == NULL) SWIG_fail;
31293             temp3 = true;
31294         }
31295     }
31296     if (obj3) {
31297         {
31298             arg4 = &temp4;
31299             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
31300         }
31301     }
31302     if (obj4) {
31303         {
31304             arg5 = &temp5;
31305             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
31306         }
31307     }
31308     if (obj5) {
31309         {
31310             arg6 = (long)(SWIG_As_long(obj5));
31311             if (SWIG_arg_fail(6)) SWIG_fail;
31312         }
31313     }
31314     if (obj6) {
31315         {
31316             arg7 = wxString_in_helper(obj6);
31317             if (arg7 == NULL) SWIG_fail;
31318             temp7 = true;
31319         }
31320     }
31321     if (obj7) {
31322         {
31323             arg8 = (int)(SWIG_As_int(obj7));
31324             if (SWIG_arg_fail(8)) SWIG_fail;
31325         }
31326     }
31327     if (obj8) {
31328         {
31329             arg9 = wxString_in_helper(obj8);
31330             if (arg9 == NULL) SWIG_fail;
31331             temp9 = true;
31332         }
31333     }
31334     {
31335         if (!wxPyCheckForApp()) SWIG_fail;
31336         PyThreadState* __tstate = wxPyBeginAllowThreads();
31337         result = (wxGenericDirCtrl *)new wxGenericDirCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7,arg8,(wxString const &)*arg9);
31338
31339         wxPyEndAllowThreads(__tstate);
31340         if (PyErr_Occurred()) SWIG_fail;
31341     }
31342     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDirCtrl, 1);
31343     {
31344         if (temp3)
31345         delete arg3;
31346     }
31347     {
31348         if (temp7)
31349         delete arg7;
31350     }
31351     {
31352         if (temp9)
31353         delete arg9;
31354     }
31355     return resultobj;
31356     fail:
31357     {
31358         if (temp3)
31359         delete arg3;
31360     }
31361     {
31362         if (temp7)
31363         delete arg7;
31364     }
31365     {
31366         if (temp9)
31367         delete arg9;
31368     }
31369     return NULL;
31370 }
31371
31372
31373 static PyObject *_wrap_new_PreGenericDirCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
31374     PyObject *resultobj;
31375     wxGenericDirCtrl *result;
31376     char *kwnames[] = {
31377         NULL
31378     };
31379
31380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGenericDirCtrl",kwnames)) goto fail;
31381     {
31382         if (!wxPyCheckForApp()) SWIG_fail;
31383         PyThreadState* __tstate = wxPyBeginAllowThreads();
31384         result = (wxGenericDirCtrl *)new wxGenericDirCtrl();
31385
31386         wxPyEndAllowThreads(__tstate);
31387         if (PyErr_Occurred()) SWIG_fail;
31388     }
31389     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDirCtrl, 1);
31390     return resultobj;
31391     fail:
31392     return NULL;
31393 }
31394
31395
31396 static PyObject *_wrap_GenericDirCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
31397     PyObject *resultobj;
31398     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31399     wxWindow *arg2 = (wxWindow *) 0 ;
31400     int arg3 = (int) (int)-1 ;
31401     wxString const &arg4_defvalue = wxPyDirDialogDefaultFolderStr ;
31402     wxString *arg4 = (wxString *) &arg4_defvalue ;
31403     wxPoint const &arg5_defvalue = wxDefaultPosition ;
31404     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
31405     wxSize const &arg6_defvalue = wxDefaultSize ;
31406     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
31407     long arg7 = (long) wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER ;
31408     wxString const &arg8_defvalue = wxPyEmptyString ;
31409     wxString *arg8 = (wxString *) &arg8_defvalue ;
31410     int arg9 = (int) 0 ;
31411     wxString const &arg10_defvalue = wxPyTreeCtrlNameStr ;
31412     wxString *arg10 = (wxString *) &arg10_defvalue ;
31413     bool result;
31414     bool temp4 = false ;
31415     wxPoint temp5 ;
31416     wxSize temp6 ;
31417     bool temp8 = false ;
31418     bool temp10 = false ;
31419     PyObject * obj0 = 0 ;
31420     PyObject * obj1 = 0 ;
31421     PyObject * obj2 = 0 ;
31422     PyObject * obj3 = 0 ;
31423     PyObject * obj4 = 0 ;
31424     PyObject * obj5 = 0 ;
31425     PyObject * obj6 = 0 ;
31426     PyObject * obj7 = 0 ;
31427     PyObject * obj8 = 0 ;
31428     PyObject * obj9 = 0 ;
31429     char *kwnames[] = {
31430         (char *) "self",(char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL
31431     };
31432
31433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:GenericDirCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
31434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31435     if (SWIG_arg_fail(1)) SWIG_fail;
31436     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31437     if (SWIG_arg_fail(2)) SWIG_fail;
31438     if (obj2) {
31439         {
31440             arg3 = (int const)(SWIG_As_int(obj2));
31441             if (SWIG_arg_fail(3)) SWIG_fail;
31442         }
31443     }
31444     if (obj3) {
31445         {
31446             arg4 = wxString_in_helper(obj3);
31447             if (arg4 == NULL) SWIG_fail;
31448             temp4 = true;
31449         }
31450     }
31451     if (obj4) {
31452         {
31453             arg5 = &temp5;
31454             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
31455         }
31456     }
31457     if (obj5) {
31458         {
31459             arg6 = &temp6;
31460             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
31461         }
31462     }
31463     if (obj6) {
31464         {
31465             arg7 = (long)(SWIG_As_long(obj6));
31466             if (SWIG_arg_fail(7)) SWIG_fail;
31467         }
31468     }
31469     if (obj7) {
31470         {
31471             arg8 = wxString_in_helper(obj7);
31472             if (arg8 == NULL) SWIG_fail;
31473             temp8 = true;
31474         }
31475     }
31476     if (obj8) {
31477         {
31478             arg9 = (int)(SWIG_As_int(obj8));
31479             if (SWIG_arg_fail(9)) SWIG_fail;
31480         }
31481     }
31482     if (obj9) {
31483         {
31484             arg10 = wxString_in_helper(obj9);
31485             if (arg10 == NULL) SWIG_fail;
31486             temp10 = true;
31487         }
31488     }
31489     {
31490         PyThreadState* __tstate = wxPyBeginAllowThreads();
31491         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8,arg9,(wxString const &)*arg10);
31492
31493         wxPyEndAllowThreads(__tstate);
31494         if (PyErr_Occurred()) SWIG_fail;
31495     }
31496     {
31497         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31498     }
31499     {
31500         if (temp4)
31501         delete arg4;
31502     }
31503     {
31504         if (temp8)
31505         delete arg8;
31506     }
31507     {
31508         if (temp10)
31509         delete arg10;
31510     }
31511     return resultobj;
31512     fail:
31513     {
31514         if (temp4)
31515         delete arg4;
31516     }
31517     {
31518         if (temp8)
31519         delete arg8;
31520     }
31521     {
31522         if (temp10)
31523         delete arg10;
31524     }
31525     return NULL;
31526 }
31527
31528
31529 static PyObject *_wrap_GenericDirCtrl_ExpandPath(PyObject *, PyObject *args, PyObject *kwargs) {
31530     PyObject *resultobj;
31531     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31532     wxString *arg2 = 0 ;
31533     bool result;
31534     bool temp2 = false ;
31535     PyObject * obj0 = 0 ;
31536     PyObject * obj1 = 0 ;
31537     char *kwnames[] = {
31538         (char *) "self",(char *) "path", NULL
31539     };
31540
31541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ExpandPath",kwnames,&obj0,&obj1)) goto fail;
31542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31543     if (SWIG_arg_fail(1)) SWIG_fail;
31544     {
31545         arg2 = wxString_in_helper(obj1);
31546         if (arg2 == NULL) SWIG_fail;
31547         temp2 = true;
31548     }
31549     {
31550         PyThreadState* __tstate = wxPyBeginAllowThreads();
31551         result = (bool)(arg1)->ExpandPath((wxString const &)*arg2);
31552
31553         wxPyEndAllowThreads(__tstate);
31554         if (PyErr_Occurred()) SWIG_fail;
31555     }
31556     {
31557         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31558     }
31559     {
31560         if (temp2)
31561         delete arg2;
31562     }
31563     return resultobj;
31564     fail:
31565     {
31566         if (temp2)
31567         delete arg2;
31568     }
31569     return NULL;
31570 }
31571
31572
31573 static PyObject *_wrap_GenericDirCtrl_GetDefaultPath(PyObject *, PyObject *args, PyObject *kwargs) {
31574     PyObject *resultobj;
31575     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31576     wxString result;
31577     PyObject * obj0 = 0 ;
31578     char *kwnames[] = {
31579         (char *) "self", NULL
31580     };
31581
31582     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetDefaultPath",kwnames,&obj0)) goto fail;
31583     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31584     if (SWIG_arg_fail(1)) SWIG_fail;
31585     {
31586         PyThreadState* __tstate = wxPyBeginAllowThreads();
31587         result = ((wxGenericDirCtrl const *)arg1)->GetDefaultPath();
31588
31589         wxPyEndAllowThreads(__tstate);
31590         if (PyErr_Occurred()) SWIG_fail;
31591     }
31592     {
31593 #if wxUSE_UNICODE
31594         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31595 #else
31596         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31597 #endif
31598     }
31599     return resultobj;
31600     fail:
31601     return NULL;
31602 }
31603
31604
31605 static PyObject *_wrap_GenericDirCtrl_SetDefaultPath(PyObject *, PyObject *args, PyObject *kwargs) {
31606     PyObject *resultobj;
31607     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31608     wxString *arg2 = 0 ;
31609     bool temp2 = false ;
31610     PyObject * obj0 = 0 ;
31611     PyObject * obj1 = 0 ;
31612     char *kwnames[] = {
31613         (char *) "self",(char *) "path", NULL
31614     };
31615
31616     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetDefaultPath",kwnames,&obj0,&obj1)) goto fail;
31617     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31618     if (SWIG_arg_fail(1)) SWIG_fail;
31619     {
31620         arg2 = wxString_in_helper(obj1);
31621         if (arg2 == NULL) SWIG_fail;
31622         temp2 = true;
31623     }
31624     {
31625         PyThreadState* __tstate = wxPyBeginAllowThreads();
31626         (arg1)->SetDefaultPath((wxString const &)*arg2);
31627
31628         wxPyEndAllowThreads(__tstate);
31629         if (PyErr_Occurred()) SWIG_fail;
31630     }
31631     Py_INCREF(Py_None); resultobj = Py_None;
31632     {
31633         if (temp2)
31634         delete arg2;
31635     }
31636     return resultobj;
31637     fail:
31638     {
31639         if (temp2)
31640         delete arg2;
31641     }
31642     return NULL;
31643 }
31644
31645
31646 static PyObject *_wrap_GenericDirCtrl_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
31647     PyObject *resultobj;
31648     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31649     wxString result;
31650     PyObject * obj0 = 0 ;
31651     char *kwnames[] = {
31652         (char *) "self", NULL
31653     };
31654
31655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetPath",kwnames,&obj0)) goto fail;
31656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31657     if (SWIG_arg_fail(1)) SWIG_fail;
31658     {
31659         PyThreadState* __tstate = wxPyBeginAllowThreads();
31660         result = ((wxGenericDirCtrl const *)arg1)->GetPath();
31661
31662         wxPyEndAllowThreads(__tstate);
31663         if (PyErr_Occurred()) SWIG_fail;
31664     }
31665     {
31666 #if wxUSE_UNICODE
31667         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31668 #else
31669         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31670 #endif
31671     }
31672     return resultobj;
31673     fail:
31674     return NULL;
31675 }
31676
31677
31678 static PyObject *_wrap_GenericDirCtrl_GetFilePath(PyObject *, PyObject *args, PyObject *kwargs) {
31679     PyObject *resultobj;
31680     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31681     wxString result;
31682     PyObject * obj0 = 0 ;
31683     char *kwnames[] = {
31684         (char *) "self", NULL
31685     };
31686
31687     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilePath",kwnames,&obj0)) goto fail;
31688     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31689     if (SWIG_arg_fail(1)) SWIG_fail;
31690     {
31691         PyThreadState* __tstate = wxPyBeginAllowThreads();
31692         result = ((wxGenericDirCtrl const *)arg1)->GetFilePath();
31693
31694         wxPyEndAllowThreads(__tstate);
31695         if (PyErr_Occurred()) SWIG_fail;
31696     }
31697     {
31698 #if wxUSE_UNICODE
31699         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31700 #else
31701         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31702 #endif
31703     }
31704     return resultobj;
31705     fail:
31706     return NULL;
31707 }
31708
31709
31710 static PyObject *_wrap_GenericDirCtrl_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
31711     PyObject *resultobj;
31712     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31713     wxString *arg2 = 0 ;
31714     bool temp2 = false ;
31715     PyObject * obj0 = 0 ;
31716     PyObject * obj1 = 0 ;
31717     char *kwnames[] = {
31718         (char *) "self",(char *) "path", NULL
31719     };
31720
31721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetPath",kwnames,&obj0,&obj1)) goto fail;
31722     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31723     if (SWIG_arg_fail(1)) SWIG_fail;
31724     {
31725         arg2 = wxString_in_helper(obj1);
31726         if (arg2 == NULL) SWIG_fail;
31727         temp2 = true;
31728     }
31729     {
31730         PyThreadState* __tstate = wxPyBeginAllowThreads();
31731         (arg1)->SetPath((wxString const &)*arg2);
31732
31733         wxPyEndAllowThreads(__tstate);
31734         if (PyErr_Occurred()) SWIG_fail;
31735     }
31736     Py_INCREF(Py_None); resultobj = Py_None;
31737     {
31738         if (temp2)
31739         delete arg2;
31740     }
31741     return resultobj;
31742     fail:
31743     {
31744         if (temp2)
31745         delete arg2;
31746     }
31747     return NULL;
31748 }
31749
31750
31751 static PyObject *_wrap_GenericDirCtrl_ShowHidden(PyObject *, PyObject *args, PyObject *kwargs) {
31752     PyObject *resultobj;
31753     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31754     bool arg2 ;
31755     PyObject * obj0 = 0 ;
31756     PyObject * obj1 = 0 ;
31757     char *kwnames[] = {
31758         (char *) "self",(char *) "show", NULL
31759     };
31760
31761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ShowHidden",kwnames,&obj0,&obj1)) goto fail;
31762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31763     if (SWIG_arg_fail(1)) SWIG_fail;
31764     {
31765         arg2 = (bool)(SWIG_As_bool(obj1));
31766         if (SWIG_arg_fail(2)) SWIG_fail;
31767     }
31768     {
31769         PyThreadState* __tstate = wxPyBeginAllowThreads();
31770         (arg1)->ShowHidden(arg2);
31771
31772         wxPyEndAllowThreads(__tstate);
31773         if (PyErr_Occurred()) SWIG_fail;
31774     }
31775     Py_INCREF(Py_None); resultobj = Py_None;
31776     return resultobj;
31777     fail:
31778     return NULL;
31779 }
31780
31781
31782 static PyObject *_wrap_GenericDirCtrl_GetShowHidden(PyObject *, PyObject *args, PyObject *kwargs) {
31783     PyObject *resultobj;
31784     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31785     bool result;
31786     PyObject * obj0 = 0 ;
31787     char *kwnames[] = {
31788         (char *) "self", NULL
31789     };
31790
31791     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetShowHidden",kwnames,&obj0)) goto fail;
31792     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31793     if (SWIG_arg_fail(1)) SWIG_fail;
31794     {
31795         PyThreadState* __tstate = wxPyBeginAllowThreads();
31796         result = (bool)(arg1)->GetShowHidden();
31797
31798         wxPyEndAllowThreads(__tstate);
31799         if (PyErr_Occurred()) SWIG_fail;
31800     }
31801     {
31802         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31803     }
31804     return resultobj;
31805     fail:
31806     return NULL;
31807 }
31808
31809
31810 static PyObject *_wrap_GenericDirCtrl_GetFilter(PyObject *, PyObject *args, PyObject *kwargs) {
31811     PyObject *resultobj;
31812     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31813     wxString result;
31814     PyObject * obj0 = 0 ;
31815     char *kwnames[] = {
31816         (char *) "self", NULL
31817     };
31818
31819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilter",kwnames,&obj0)) goto fail;
31820     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31821     if (SWIG_arg_fail(1)) SWIG_fail;
31822     {
31823         PyThreadState* __tstate = wxPyBeginAllowThreads();
31824         result = ((wxGenericDirCtrl const *)arg1)->GetFilter();
31825
31826         wxPyEndAllowThreads(__tstate);
31827         if (PyErr_Occurred()) SWIG_fail;
31828     }
31829     {
31830 #if wxUSE_UNICODE
31831         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31832 #else
31833         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31834 #endif
31835     }
31836     return resultobj;
31837     fail:
31838     return NULL;
31839 }
31840
31841
31842 static PyObject *_wrap_GenericDirCtrl_SetFilter(PyObject *, PyObject *args, PyObject *kwargs) {
31843     PyObject *resultobj;
31844     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31845     wxString *arg2 = 0 ;
31846     bool temp2 = false ;
31847     PyObject * obj0 = 0 ;
31848     PyObject * obj1 = 0 ;
31849     char *kwnames[] = {
31850         (char *) "self",(char *) "filter", NULL
31851     };
31852
31853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilter",kwnames,&obj0,&obj1)) goto fail;
31854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31855     if (SWIG_arg_fail(1)) SWIG_fail;
31856     {
31857         arg2 = wxString_in_helper(obj1);
31858         if (arg2 == NULL) SWIG_fail;
31859         temp2 = true;
31860     }
31861     {
31862         PyThreadState* __tstate = wxPyBeginAllowThreads();
31863         (arg1)->SetFilter((wxString const &)*arg2);
31864
31865         wxPyEndAllowThreads(__tstate);
31866         if (PyErr_Occurred()) SWIG_fail;
31867     }
31868     Py_INCREF(Py_None); resultobj = Py_None;
31869     {
31870         if (temp2)
31871         delete arg2;
31872     }
31873     return resultobj;
31874     fail:
31875     {
31876         if (temp2)
31877         delete arg2;
31878     }
31879     return NULL;
31880 }
31881
31882
31883 static PyObject *_wrap_GenericDirCtrl_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
31884     PyObject *resultobj;
31885     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31886     int result;
31887     PyObject * obj0 = 0 ;
31888     char *kwnames[] = {
31889         (char *) "self", NULL
31890     };
31891
31892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilterIndex",kwnames,&obj0)) goto fail;
31893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31894     if (SWIG_arg_fail(1)) SWIG_fail;
31895     {
31896         PyThreadState* __tstate = wxPyBeginAllowThreads();
31897         result = (int)((wxGenericDirCtrl const *)arg1)->GetFilterIndex();
31898
31899         wxPyEndAllowThreads(__tstate);
31900         if (PyErr_Occurred()) SWIG_fail;
31901     }
31902     {
31903         resultobj = SWIG_From_int((int)(result));
31904     }
31905     return resultobj;
31906     fail:
31907     return NULL;
31908 }
31909
31910
31911 static PyObject *_wrap_GenericDirCtrl_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
31912     PyObject *resultobj;
31913     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31914     int arg2 ;
31915     PyObject * obj0 = 0 ;
31916     PyObject * obj1 = 0 ;
31917     char *kwnames[] = {
31918         (char *) "self",(char *) "n", NULL
31919     };
31920
31921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
31922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31923     if (SWIG_arg_fail(1)) SWIG_fail;
31924     {
31925         arg2 = (int)(SWIG_As_int(obj1));
31926         if (SWIG_arg_fail(2)) SWIG_fail;
31927     }
31928     {
31929         PyThreadState* __tstate = wxPyBeginAllowThreads();
31930         (arg1)->SetFilterIndex(arg2);
31931
31932         wxPyEndAllowThreads(__tstate);
31933         if (PyErr_Occurred()) SWIG_fail;
31934     }
31935     Py_INCREF(Py_None); resultobj = Py_None;
31936     return resultobj;
31937     fail:
31938     return NULL;
31939 }
31940
31941
31942 static PyObject *_wrap_GenericDirCtrl_GetRootId(PyObject *, PyObject *args, PyObject *kwargs) {
31943     PyObject *resultobj;
31944     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31945     wxTreeItemId result;
31946     PyObject * obj0 = 0 ;
31947     char *kwnames[] = {
31948         (char *) "self", NULL
31949     };
31950
31951     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetRootId",kwnames,&obj0)) goto fail;
31952     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31953     if (SWIG_arg_fail(1)) SWIG_fail;
31954     {
31955         PyThreadState* __tstate = wxPyBeginAllowThreads();
31956         result = (arg1)->GetRootId();
31957
31958         wxPyEndAllowThreads(__tstate);
31959         if (PyErr_Occurred()) SWIG_fail;
31960     }
31961     {
31962         wxTreeItemId * resultptr;
31963         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
31964         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
31965     }
31966     return resultobj;
31967     fail:
31968     return NULL;
31969 }
31970
31971
31972 static PyObject *_wrap_GenericDirCtrl_GetTreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
31973     PyObject *resultobj;
31974     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31975     wxPyTreeCtrl *result;
31976     PyObject * obj0 = 0 ;
31977     char *kwnames[] = {
31978         (char *) "self", NULL
31979     };
31980
31981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetTreeCtrl",kwnames,&obj0)) goto fail;
31982     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31983     if (SWIG_arg_fail(1)) SWIG_fail;
31984     {
31985         PyThreadState* __tstate = wxPyBeginAllowThreads();
31986         result = (wxPyTreeCtrl *)((wxGenericDirCtrl const *)arg1)->GetTreeCtrl();
31987
31988         wxPyEndAllowThreads(__tstate);
31989         if (PyErr_Occurred()) SWIG_fail;
31990     }
31991     {
31992         resultobj = wxPyMake_wxObject(result, 0);
31993     }
31994     return resultobj;
31995     fail:
31996     return NULL;
31997 }
31998
31999
32000 static PyObject *_wrap_GenericDirCtrl_GetFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32001     PyObject *resultobj;
32002     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32003     wxDirFilterListCtrl *result;
32004     PyObject * obj0 = 0 ;
32005     char *kwnames[] = {
32006         (char *) "self", NULL
32007     };
32008
32009     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilterListCtrl",kwnames,&obj0)) goto fail;
32010     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32011     if (SWIG_arg_fail(1)) SWIG_fail;
32012     {
32013         PyThreadState* __tstate = wxPyBeginAllowThreads();
32014         result = (wxDirFilterListCtrl *)((wxGenericDirCtrl const *)arg1)->GetFilterListCtrl();
32015
32016         wxPyEndAllowThreads(__tstate);
32017         if (PyErr_Occurred()) SWIG_fail;
32018     }
32019     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 0);
32020     return resultobj;
32021     fail:
32022     return NULL;
32023 }
32024
32025
32026 static PyObject *_wrap_GenericDirCtrl_FindChild(PyObject *, PyObject *args, PyObject *kwargs) {
32027     PyObject *resultobj;
32028     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32029     wxTreeItemId arg2 ;
32030     wxString *arg3 = 0 ;
32031     bool *arg4 = 0 ;
32032     wxTreeItemId result;
32033     bool temp3 = false ;
32034     bool temp4 ;
32035     int res4 = 0 ;
32036     PyObject * obj0 = 0 ;
32037     PyObject * obj1 = 0 ;
32038     PyObject * obj2 = 0 ;
32039     char *kwnames[] = {
32040         (char *) "self",(char *) "parentId",(char *) "path", NULL
32041     };
32042
32043     arg4 = &temp4; res4 = SWIG_NEWOBJ;
32044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GenericDirCtrl_FindChild",kwnames,&obj0,&obj1,&obj2)) goto fail;
32045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32046     if (SWIG_arg_fail(1)) SWIG_fail;
32047     {
32048         wxTreeItemId * argp;
32049         SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION);
32050         if (SWIG_arg_fail(2)) SWIG_fail;
32051         if (argp == NULL) {
32052             SWIG_null_ref("wxTreeItemId");
32053         }
32054         if (SWIG_arg_fail(2)) SWIG_fail;
32055         arg2 = *argp;
32056     }
32057     {
32058         arg3 = wxString_in_helper(obj2);
32059         if (arg3 == NULL) SWIG_fail;
32060         temp3 = true;
32061     }
32062     {
32063         PyThreadState* __tstate = wxPyBeginAllowThreads();
32064         result = (arg1)->FindChild(arg2,(wxString const &)*arg3,*arg4);
32065
32066         wxPyEndAllowThreads(__tstate);
32067         if (PyErr_Occurred()) SWIG_fail;
32068     }
32069     {
32070         wxTreeItemId * resultptr;
32071         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
32072         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
32073     }
32074     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
32075     SWIG_From_bool((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_bool, 0)));
32076     {
32077         if (temp3)
32078         delete arg3;
32079     }
32080     return resultobj;
32081     fail:
32082     {
32083         if (temp3)
32084         delete arg3;
32085     }
32086     return NULL;
32087 }
32088
32089
32090 static PyObject *_wrap_GenericDirCtrl_DoResize(PyObject *, PyObject *args, PyObject *kwargs) {
32091     PyObject *resultobj;
32092     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32093     PyObject * obj0 = 0 ;
32094     char *kwnames[] = {
32095         (char *) "self", NULL
32096     };
32097
32098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_DoResize",kwnames,&obj0)) goto fail;
32099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32100     if (SWIG_arg_fail(1)) SWIG_fail;
32101     {
32102         PyThreadState* __tstate = wxPyBeginAllowThreads();
32103         (arg1)->DoResize();
32104
32105         wxPyEndAllowThreads(__tstate);
32106         if (PyErr_Occurred()) SWIG_fail;
32107     }
32108     Py_INCREF(Py_None); resultobj = Py_None;
32109     return resultobj;
32110     fail:
32111     return NULL;
32112 }
32113
32114
32115 static PyObject *_wrap_GenericDirCtrl_ReCreateTree(PyObject *, PyObject *args, PyObject *kwargs) {
32116     PyObject *resultobj;
32117     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32118     PyObject * obj0 = 0 ;
32119     char *kwnames[] = {
32120         (char *) "self", NULL
32121     };
32122
32123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_ReCreateTree",kwnames,&obj0)) goto fail;
32124     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32125     if (SWIG_arg_fail(1)) SWIG_fail;
32126     {
32127         PyThreadState* __tstate = wxPyBeginAllowThreads();
32128         (arg1)->ReCreateTree();
32129
32130         wxPyEndAllowThreads(__tstate);
32131         if (PyErr_Occurred()) SWIG_fail;
32132     }
32133     Py_INCREF(Py_None); resultobj = Py_None;
32134     return resultobj;
32135     fail:
32136     return NULL;
32137 }
32138
32139
32140 static PyObject * GenericDirCtrl_swigregister(PyObject *, PyObject *args) {
32141     PyObject *obj;
32142     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32143     SWIG_TypeClientData(SWIGTYPE_p_wxGenericDirCtrl, obj);
32144     Py_INCREF(obj);
32145     return Py_BuildValue((char *)"");
32146 }
32147 static PyObject *_wrap_new_DirFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32148     PyObject *resultobj;
32149     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32150     int arg2 = (int) (int)-1 ;
32151     wxPoint const &arg3_defvalue = wxDefaultPosition ;
32152     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32153     wxSize const &arg4_defvalue = wxDefaultSize ;
32154     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32155     long arg5 = (long) 0 ;
32156     wxDirFilterListCtrl *result;
32157     wxPoint temp3 ;
32158     wxSize temp4 ;
32159     PyObject * obj0 = 0 ;
32160     PyObject * obj1 = 0 ;
32161     PyObject * obj2 = 0 ;
32162     PyObject * obj3 = 0 ;
32163     PyObject * obj4 = 0 ;
32164     char *kwnames[] = {
32165         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
32166     };
32167
32168     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_DirFilterListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32169     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32170     if (SWIG_arg_fail(1)) SWIG_fail;
32171     if (obj1) {
32172         {
32173             arg2 = (int const)(SWIG_As_int(obj1));
32174             if (SWIG_arg_fail(2)) SWIG_fail;
32175         }
32176     }
32177     if (obj2) {
32178         {
32179             arg3 = &temp3;
32180             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32181         }
32182     }
32183     if (obj3) {
32184         {
32185             arg4 = &temp4;
32186             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32187         }
32188     }
32189     if (obj4) {
32190         {
32191             arg5 = (long)(SWIG_As_long(obj4));
32192             if (SWIG_arg_fail(5)) SWIG_fail;
32193         }
32194     }
32195     {
32196         if (!wxPyCheckForApp()) SWIG_fail;
32197         PyThreadState* __tstate = wxPyBeginAllowThreads();
32198         result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
32199
32200         wxPyEndAllowThreads(__tstate);
32201         if (PyErr_Occurred()) SWIG_fail;
32202     }
32203     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 1);
32204     return resultobj;
32205     fail:
32206     return NULL;
32207 }
32208
32209
32210 static PyObject *_wrap_new_PreDirFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32211     PyObject *resultobj;
32212     wxDirFilterListCtrl *result;
32213     char *kwnames[] = {
32214         NULL
32215     };
32216
32217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDirFilterListCtrl",kwnames)) goto fail;
32218     {
32219         if (!wxPyCheckForApp()) SWIG_fail;
32220         PyThreadState* __tstate = wxPyBeginAllowThreads();
32221         result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl();
32222
32223         wxPyEndAllowThreads(__tstate);
32224         if (PyErr_Occurred()) SWIG_fail;
32225     }
32226     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 1);
32227     return resultobj;
32228     fail:
32229     return NULL;
32230 }
32231
32232
32233 static PyObject *_wrap_DirFilterListCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
32234     PyObject *resultobj;
32235     wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
32236     wxGenericDirCtrl *arg2 = (wxGenericDirCtrl *) 0 ;
32237     int arg3 = (int) (int)-1 ;
32238     wxPoint const &arg4_defvalue = wxDefaultPosition ;
32239     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32240     wxSize const &arg5_defvalue = wxDefaultSize ;
32241     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32242     long arg6 = (long) 0 ;
32243     bool result;
32244     wxPoint temp4 ;
32245     wxSize temp5 ;
32246     PyObject * obj0 = 0 ;
32247     PyObject * obj1 = 0 ;
32248     PyObject * obj2 = 0 ;
32249     PyObject * obj3 = 0 ;
32250     PyObject * obj4 = 0 ;
32251     PyObject * obj5 = 0 ;
32252     char *kwnames[] = {
32253         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
32254     };
32255
32256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:DirFilterListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32257     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_EXCEPTION | 0);
32258     if (SWIG_arg_fail(1)) SWIG_fail;
32259     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32260     if (SWIG_arg_fail(2)) SWIG_fail;
32261     if (obj2) {
32262         {
32263             arg3 = (int const)(SWIG_As_int(obj2));
32264             if (SWIG_arg_fail(3)) SWIG_fail;
32265         }
32266     }
32267     if (obj3) {
32268         {
32269             arg4 = &temp4;
32270             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32271         }
32272     }
32273     if (obj4) {
32274         {
32275             arg5 = &temp5;
32276             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32277         }
32278     }
32279     if (obj5) {
32280         {
32281             arg6 = (long)(SWIG_As_long(obj5));
32282             if (SWIG_arg_fail(6)) SWIG_fail;
32283         }
32284     }
32285     {
32286         PyThreadState* __tstate = wxPyBeginAllowThreads();
32287         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
32288
32289         wxPyEndAllowThreads(__tstate);
32290         if (PyErr_Occurred()) SWIG_fail;
32291     }
32292     {
32293         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32294     }
32295     return resultobj;
32296     fail:
32297     return NULL;
32298 }
32299
32300
32301 static PyObject *_wrap_DirFilterListCtrl_FillFilterList(PyObject *, PyObject *args, PyObject *kwargs) {
32302     PyObject *resultobj;
32303     wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
32304     wxString *arg2 = 0 ;
32305     int arg3 ;
32306     bool temp2 = false ;
32307     PyObject * obj0 = 0 ;
32308     PyObject * obj1 = 0 ;
32309     PyObject * obj2 = 0 ;
32310     char *kwnames[] = {
32311         (char *) "self",(char *) "filter",(char *) "defaultFilter", NULL
32312     };
32313
32314     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DirFilterListCtrl_FillFilterList",kwnames,&obj0,&obj1,&obj2)) goto fail;
32315     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_EXCEPTION | 0);
32316     if (SWIG_arg_fail(1)) SWIG_fail;
32317     {
32318         arg2 = wxString_in_helper(obj1);
32319         if (arg2 == NULL) SWIG_fail;
32320         temp2 = true;
32321     }
32322     {
32323         arg3 = (int)(SWIG_As_int(obj2));
32324         if (SWIG_arg_fail(3)) SWIG_fail;
32325     }
32326     {
32327         PyThreadState* __tstate = wxPyBeginAllowThreads();
32328         (arg1)->FillFilterList((wxString const &)*arg2,arg3);
32329
32330         wxPyEndAllowThreads(__tstate);
32331         if (PyErr_Occurred()) SWIG_fail;
32332     }
32333     Py_INCREF(Py_None); resultobj = Py_None;
32334     {
32335         if (temp2)
32336         delete arg2;
32337     }
32338     return resultobj;
32339     fail:
32340     {
32341         if (temp2)
32342         delete arg2;
32343     }
32344     return NULL;
32345 }
32346
32347
32348 static PyObject * DirFilterListCtrl_swigregister(PyObject *, PyObject *args) {
32349     PyObject *obj;
32350     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32351     SWIG_TypeClientData(SWIGTYPE_p_wxDirFilterListCtrl, obj);
32352     Py_INCREF(obj);
32353     return Py_BuildValue((char *)"");
32354 }
32355 static PyObject *_wrap_new_PyControl(PyObject *, PyObject *args, PyObject *kwargs) {
32356     PyObject *resultobj;
32357     wxWindow *arg1 = (wxWindow *) 0 ;
32358     int arg2 = (int) (int)-1 ;
32359     wxPoint const &arg3_defvalue = wxDefaultPosition ;
32360     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32361     wxSize const &arg4_defvalue = wxDefaultSize ;
32362     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32363     long arg5 = (long) 0 ;
32364     wxValidator const &arg6_defvalue = wxDefaultValidator ;
32365     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
32366     wxString const &arg7_defvalue = wxPyControlNameStr ;
32367     wxString *arg7 = (wxString *) &arg7_defvalue ;
32368     wxPyControl *result;
32369     wxPoint temp3 ;
32370     wxSize temp4 ;
32371     bool temp7 = false ;
32372     PyObject * obj0 = 0 ;
32373     PyObject * obj1 = 0 ;
32374     PyObject * obj2 = 0 ;
32375     PyObject * obj3 = 0 ;
32376     PyObject * obj4 = 0 ;
32377     PyObject * obj5 = 0 ;
32378     PyObject * obj6 = 0 ;
32379     char *kwnames[] = {
32380         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
32381     };
32382
32383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_PyControl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
32384     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32385     if (SWIG_arg_fail(1)) SWIG_fail;
32386     if (obj1) {
32387         {
32388             arg2 = (int const)(SWIG_As_int(obj1));
32389             if (SWIG_arg_fail(2)) SWIG_fail;
32390         }
32391     }
32392     if (obj2) {
32393         {
32394             arg3 = &temp3;
32395             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32396         }
32397     }
32398     if (obj3) {
32399         {
32400             arg4 = &temp4;
32401             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32402         }
32403     }
32404     if (obj4) {
32405         {
32406             arg5 = (long)(SWIG_As_long(obj4));
32407             if (SWIG_arg_fail(5)) SWIG_fail;
32408         }
32409     }
32410     if (obj5) {
32411         {
32412             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32413             if (SWIG_arg_fail(6)) SWIG_fail;
32414             if (arg6 == NULL) {
32415                 SWIG_null_ref("wxValidator");
32416             }
32417             if (SWIG_arg_fail(6)) SWIG_fail;
32418         }
32419     }
32420     if (obj6) {
32421         {
32422             arg7 = wxString_in_helper(obj6);
32423             if (arg7 == NULL) SWIG_fail;
32424             temp7 = true;
32425         }
32426     }
32427     {
32428         if (!wxPyCheckForApp()) SWIG_fail;
32429         PyThreadState* __tstate = wxPyBeginAllowThreads();
32430         result = (wxPyControl *)new wxPyControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
32431
32432         wxPyEndAllowThreads(__tstate);
32433         if (PyErr_Occurred()) SWIG_fail;
32434     }
32435     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyControl, 1);
32436     {
32437         if (temp7)
32438         delete arg7;
32439     }
32440     return resultobj;
32441     fail:
32442     {
32443         if (temp7)
32444         delete arg7;
32445     }
32446     return NULL;
32447 }
32448
32449
32450 static PyObject *_wrap_new_PrePyControl(PyObject *, PyObject *args, PyObject *kwargs) {
32451     PyObject *resultobj;
32452     wxPyControl *result;
32453     char *kwnames[] = {
32454         NULL
32455     };
32456
32457     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyControl",kwnames)) goto fail;
32458     {
32459         if (!wxPyCheckForApp()) SWIG_fail;
32460         PyThreadState* __tstate = wxPyBeginAllowThreads();
32461         result = (wxPyControl *)new wxPyControl();
32462
32463         wxPyEndAllowThreads(__tstate);
32464         if (PyErr_Occurred()) SWIG_fail;
32465     }
32466     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyControl, 1);
32467     return resultobj;
32468     fail:
32469     return NULL;
32470 }
32471
32472
32473 static PyObject *_wrap_PyControl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32474     PyObject *resultobj;
32475     wxPyControl *arg1 = (wxPyControl *) 0 ;
32476     PyObject *arg2 = (PyObject *) 0 ;
32477     PyObject *arg3 = (PyObject *) 0 ;
32478     PyObject * obj0 = 0 ;
32479     PyObject * obj1 = 0 ;
32480     PyObject * obj2 = 0 ;
32481     char *kwnames[] = {
32482         (char *) "self",(char *) "self",(char *) "_class", NULL
32483     };
32484
32485     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
32486     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32487     if (SWIG_arg_fail(1)) SWIG_fail;
32488     arg2 = obj1;
32489     arg3 = obj2;
32490     {
32491         PyThreadState* __tstate = wxPyBeginAllowThreads();
32492         (arg1)->_setCallbackInfo(arg2,arg3);
32493
32494         wxPyEndAllowThreads(__tstate);
32495         if (PyErr_Occurred()) SWIG_fail;
32496     }
32497     Py_INCREF(Py_None); resultobj = Py_None;
32498     return resultobj;
32499     fail:
32500     return NULL;
32501 }
32502
32503
32504 static PyObject *_wrap_PyControl_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
32505     PyObject *resultobj;
32506     wxPyControl *arg1 = (wxPyControl *) 0 ;
32507     wxSize *arg2 = 0 ;
32508     wxSize temp2 ;
32509     PyObject * obj0 = 0 ;
32510     PyObject * obj1 = 0 ;
32511     char *kwnames[] = {
32512         (char *) "self",(char *) "size", NULL
32513     };
32514
32515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
32516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32517     if (SWIG_arg_fail(1)) SWIG_fail;
32518     {
32519         arg2 = &temp2;
32520         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32521     }
32522     {
32523         PyThreadState* __tstate = wxPyBeginAllowThreads();
32524         (arg1)->SetBestSize((wxSize const &)*arg2);
32525
32526         wxPyEndAllowThreads(__tstate);
32527         if (PyErr_Occurred()) SWIG_fail;
32528     }
32529     Py_INCREF(Py_None); resultobj = Py_None;
32530     return resultobj;
32531     fail:
32532     return NULL;
32533 }
32534
32535
32536 static PyObject *_wrap_PyControl_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32537     PyObject *resultobj;
32538     wxPyControl *arg1 = (wxPyControl *) 0 ;
32539     int arg2 ;
32540     int arg3 ;
32541     int arg4 ;
32542     int arg5 ;
32543     PyObject * obj0 = 0 ;
32544     PyObject * obj1 = 0 ;
32545     PyObject * obj2 = 0 ;
32546     PyObject * obj3 = 0 ;
32547     PyObject * obj4 = 0 ;
32548     char *kwnames[] = {
32549         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
32550     };
32551
32552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyControl_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32554     if (SWIG_arg_fail(1)) SWIG_fail;
32555     {
32556         arg2 = (int)(SWIG_As_int(obj1));
32557         if (SWIG_arg_fail(2)) SWIG_fail;
32558     }
32559     {
32560         arg3 = (int)(SWIG_As_int(obj2));
32561         if (SWIG_arg_fail(3)) SWIG_fail;
32562     }
32563     {
32564         arg4 = (int)(SWIG_As_int(obj3));
32565         if (SWIG_arg_fail(4)) SWIG_fail;
32566     }
32567     {
32568         arg5 = (int)(SWIG_As_int(obj4));
32569         if (SWIG_arg_fail(5)) SWIG_fail;
32570     }
32571     {
32572         PyThreadState* __tstate = wxPyBeginAllowThreads();
32573         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
32574
32575         wxPyEndAllowThreads(__tstate);
32576         if (PyErr_Occurred()) SWIG_fail;
32577     }
32578     Py_INCREF(Py_None); resultobj = Py_None;
32579     return resultobj;
32580     fail:
32581     return NULL;
32582 }
32583
32584
32585 static PyObject *_wrap_PyControl_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
32586     PyObject *resultobj;
32587     wxPyControl *arg1 = (wxPyControl *) 0 ;
32588     int arg2 ;
32589     int arg3 ;
32590     int arg4 ;
32591     int arg5 ;
32592     int arg6 = (int) wxSIZE_AUTO ;
32593     PyObject * obj0 = 0 ;
32594     PyObject * obj1 = 0 ;
32595     PyObject * obj2 = 0 ;
32596     PyObject * obj3 = 0 ;
32597     PyObject * obj4 = 0 ;
32598     PyObject * obj5 = 0 ;
32599     char *kwnames[] = {
32600         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
32601     };
32602
32603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyControl_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32605     if (SWIG_arg_fail(1)) SWIG_fail;
32606     {
32607         arg2 = (int)(SWIG_As_int(obj1));
32608         if (SWIG_arg_fail(2)) SWIG_fail;
32609     }
32610     {
32611         arg3 = (int)(SWIG_As_int(obj2));
32612         if (SWIG_arg_fail(3)) SWIG_fail;
32613     }
32614     {
32615         arg4 = (int)(SWIG_As_int(obj3));
32616         if (SWIG_arg_fail(4)) SWIG_fail;
32617     }
32618     {
32619         arg5 = (int)(SWIG_As_int(obj4));
32620         if (SWIG_arg_fail(5)) SWIG_fail;
32621     }
32622     if (obj5) {
32623         {
32624             arg6 = (int)(SWIG_As_int(obj5));
32625             if (SWIG_arg_fail(6)) SWIG_fail;
32626         }
32627     }
32628     {
32629         PyThreadState* __tstate = wxPyBeginAllowThreads();
32630         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
32631
32632         wxPyEndAllowThreads(__tstate);
32633         if (PyErr_Occurred()) SWIG_fail;
32634     }
32635     Py_INCREF(Py_None); resultobj = Py_None;
32636     return resultobj;
32637     fail:
32638     return NULL;
32639 }
32640
32641
32642 static PyObject *_wrap_PyControl_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
32643     PyObject *resultobj;
32644     wxPyControl *arg1 = (wxPyControl *) 0 ;
32645     int arg2 ;
32646     int arg3 ;
32647     PyObject * obj0 = 0 ;
32648     PyObject * obj1 = 0 ;
32649     PyObject * obj2 = 0 ;
32650     char *kwnames[] = {
32651         (char *) "self",(char *) "width",(char *) "height", NULL
32652     };
32653
32654     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
32655     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32656     if (SWIG_arg_fail(1)) SWIG_fail;
32657     {
32658         arg2 = (int)(SWIG_As_int(obj1));
32659         if (SWIG_arg_fail(2)) SWIG_fail;
32660     }
32661     {
32662         arg3 = (int)(SWIG_As_int(obj2));
32663         if (SWIG_arg_fail(3)) SWIG_fail;
32664     }
32665     {
32666         PyThreadState* __tstate = wxPyBeginAllowThreads();
32667         (arg1)->base_DoSetClientSize(arg2,arg3);
32668
32669         wxPyEndAllowThreads(__tstate);
32670         if (PyErr_Occurred()) SWIG_fail;
32671     }
32672     Py_INCREF(Py_None); resultobj = Py_None;
32673     return resultobj;
32674     fail:
32675     return NULL;
32676 }
32677
32678
32679 static PyObject *_wrap_PyControl_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
32680     PyObject *resultobj;
32681     wxPyControl *arg1 = (wxPyControl *) 0 ;
32682     int arg2 ;
32683     int arg3 ;
32684     PyObject * obj0 = 0 ;
32685     PyObject * obj1 = 0 ;
32686     PyObject * obj2 = 0 ;
32687     char *kwnames[] = {
32688         (char *) "self",(char *) "x",(char *) "y", NULL
32689     };
32690
32691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
32692     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32693     if (SWIG_arg_fail(1)) SWIG_fail;
32694     {
32695         arg2 = (int)(SWIG_As_int(obj1));
32696         if (SWIG_arg_fail(2)) SWIG_fail;
32697     }
32698     {
32699         arg3 = (int)(SWIG_As_int(obj2));
32700         if (SWIG_arg_fail(3)) SWIG_fail;
32701     }
32702     {
32703         PyThreadState* __tstate = wxPyBeginAllowThreads();
32704         (arg1)->base_DoSetVirtualSize(arg2,arg3);
32705
32706         wxPyEndAllowThreads(__tstate);
32707         if (PyErr_Occurred()) SWIG_fail;
32708     }
32709     Py_INCREF(Py_None); resultobj = Py_None;
32710     return resultobj;
32711     fail:
32712     return NULL;
32713 }
32714
32715
32716 static PyObject *_wrap_PyControl_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
32717     PyObject *resultobj;
32718     wxPyControl *arg1 = (wxPyControl *) 0 ;
32719     int *arg2 = (int *) 0 ;
32720     int *arg3 = (int *) 0 ;
32721     int temp2 ;
32722     int res2 = 0 ;
32723     int temp3 ;
32724     int res3 = 0 ;
32725     PyObject * obj0 = 0 ;
32726     char *kwnames[] = {
32727         (char *) "self", NULL
32728     };
32729
32730     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32731     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32732     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetSize",kwnames,&obj0)) goto fail;
32733     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32734     if (SWIG_arg_fail(1)) SWIG_fail;
32735     {
32736         PyThreadState* __tstate = wxPyBeginAllowThreads();
32737         ((wxPyControl const *)arg1)->base_DoGetSize(arg2,arg3);
32738
32739         wxPyEndAllowThreads(__tstate);
32740         if (PyErr_Occurred()) SWIG_fail;
32741     }
32742     Py_INCREF(Py_None); resultobj = Py_None;
32743     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32744     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32745     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32746     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32747     return resultobj;
32748     fail:
32749     return NULL;
32750 }
32751
32752
32753 static PyObject *_wrap_PyControl_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
32754     PyObject *resultobj;
32755     wxPyControl *arg1 = (wxPyControl *) 0 ;
32756     int *arg2 = (int *) 0 ;
32757     int *arg3 = (int *) 0 ;
32758     int temp2 ;
32759     int res2 = 0 ;
32760     int temp3 ;
32761     int res3 = 0 ;
32762     PyObject * obj0 = 0 ;
32763     char *kwnames[] = {
32764         (char *) "self", NULL
32765     };
32766
32767     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32768     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32769     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetClientSize",kwnames,&obj0)) goto fail;
32770     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32771     if (SWIG_arg_fail(1)) SWIG_fail;
32772     {
32773         PyThreadState* __tstate = wxPyBeginAllowThreads();
32774         ((wxPyControl const *)arg1)->base_DoGetClientSize(arg2,arg3);
32775
32776         wxPyEndAllowThreads(__tstate);
32777         if (PyErr_Occurred()) SWIG_fail;
32778     }
32779     Py_INCREF(Py_None); resultobj = Py_None;
32780     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32781     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32782     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32783     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32784     return resultobj;
32785     fail:
32786     return NULL;
32787 }
32788
32789
32790 static PyObject *_wrap_PyControl_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
32791     PyObject *resultobj;
32792     wxPyControl *arg1 = (wxPyControl *) 0 ;
32793     int *arg2 = (int *) 0 ;
32794     int *arg3 = (int *) 0 ;
32795     int temp2 ;
32796     int res2 = 0 ;
32797     int temp3 ;
32798     int res3 = 0 ;
32799     PyObject * obj0 = 0 ;
32800     char *kwnames[] = {
32801         (char *) "self", NULL
32802     };
32803
32804     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32805     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetPosition",kwnames,&obj0)) goto fail;
32807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32808     if (SWIG_arg_fail(1)) SWIG_fail;
32809     {
32810         PyThreadState* __tstate = wxPyBeginAllowThreads();
32811         ((wxPyControl const *)arg1)->base_DoGetPosition(arg2,arg3);
32812
32813         wxPyEndAllowThreads(__tstate);
32814         if (PyErr_Occurred()) SWIG_fail;
32815     }
32816     Py_INCREF(Py_None); resultobj = Py_None;
32817     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32818     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32819     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32820     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32821     return resultobj;
32822     fail:
32823     return NULL;
32824 }
32825
32826
32827 static PyObject *_wrap_PyControl_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
32828     PyObject *resultobj;
32829     wxPyControl *arg1 = (wxPyControl *) 0 ;
32830     wxSize result;
32831     PyObject * obj0 = 0 ;
32832     char *kwnames[] = {
32833         (char *) "self", NULL
32834     };
32835
32836     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
32837     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32838     if (SWIG_arg_fail(1)) SWIG_fail;
32839     {
32840         PyThreadState* __tstate = wxPyBeginAllowThreads();
32841         result = ((wxPyControl const *)arg1)->base_DoGetVirtualSize();
32842
32843         wxPyEndAllowThreads(__tstate);
32844         if (PyErr_Occurred()) SWIG_fail;
32845     }
32846     {
32847         wxSize * resultptr;
32848         resultptr = new wxSize((wxSize &)(result));
32849         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
32850     }
32851     return resultobj;
32852     fail:
32853     return NULL;
32854 }
32855
32856
32857 static PyObject *_wrap_PyControl_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
32858     PyObject *resultobj;
32859     wxPyControl *arg1 = (wxPyControl *) 0 ;
32860     wxSize result;
32861     PyObject * obj0 = 0 ;
32862     char *kwnames[] = {
32863         (char *) "self", NULL
32864     };
32865
32866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetBestSize",kwnames,&obj0)) goto fail;
32867     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32868     if (SWIG_arg_fail(1)) SWIG_fail;
32869     {
32870         PyThreadState* __tstate = wxPyBeginAllowThreads();
32871         result = ((wxPyControl const *)arg1)->base_DoGetBestSize();
32872
32873         wxPyEndAllowThreads(__tstate);
32874         if (PyErr_Occurred()) SWIG_fail;
32875     }
32876     {
32877         wxSize * resultptr;
32878         resultptr = new wxSize((wxSize &)(result));
32879         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
32880     }
32881     return resultobj;
32882     fail:
32883     return NULL;
32884 }
32885
32886
32887 static PyObject *_wrap_PyControl_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
32888     PyObject *resultobj;
32889     wxPyControl *arg1 = (wxPyControl *) 0 ;
32890     PyObject * obj0 = 0 ;
32891     char *kwnames[] = {
32892         (char *) "self", NULL
32893     };
32894
32895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_InitDialog",kwnames,&obj0)) goto fail;
32896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32897     if (SWIG_arg_fail(1)) SWIG_fail;
32898     {
32899         PyThreadState* __tstate = wxPyBeginAllowThreads();
32900         (arg1)->base_InitDialog();
32901
32902         wxPyEndAllowThreads(__tstate);
32903         if (PyErr_Occurred()) SWIG_fail;
32904     }
32905     Py_INCREF(Py_None); resultobj = Py_None;
32906     return resultobj;
32907     fail:
32908     return NULL;
32909 }
32910
32911
32912 static PyObject *_wrap_PyControl_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32913     PyObject *resultobj;
32914     wxPyControl *arg1 = (wxPyControl *) 0 ;
32915     bool result;
32916     PyObject * obj0 = 0 ;
32917     char *kwnames[] = {
32918         (char *) "self", NULL
32919     };
32920
32921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
32922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32923     if (SWIG_arg_fail(1)) SWIG_fail;
32924     {
32925         PyThreadState* __tstate = wxPyBeginAllowThreads();
32926         result = (bool)(arg1)->base_TransferDataToWindow();
32927
32928         wxPyEndAllowThreads(__tstate);
32929         if (PyErr_Occurred()) SWIG_fail;
32930     }
32931     {
32932         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32933     }
32934     return resultobj;
32935     fail:
32936     return NULL;
32937 }
32938
32939
32940 static PyObject *_wrap_PyControl_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32941     PyObject *resultobj;
32942     wxPyControl *arg1 = (wxPyControl *) 0 ;
32943     bool result;
32944     PyObject * obj0 = 0 ;
32945     char *kwnames[] = {
32946         (char *) "self", NULL
32947     };
32948
32949     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
32950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32951     if (SWIG_arg_fail(1)) SWIG_fail;
32952     {
32953         PyThreadState* __tstate = wxPyBeginAllowThreads();
32954         result = (bool)(arg1)->base_TransferDataFromWindow();
32955
32956         wxPyEndAllowThreads(__tstate);
32957         if (PyErr_Occurred()) SWIG_fail;
32958     }
32959     {
32960         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32961     }
32962     return resultobj;
32963     fail:
32964     return NULL;
32965 }
32966
32967
32968 static PyObject *_wrap_PyControl_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32969     PyObject *resultobj;
32970     wxPyControl *arg1 = (wxPyControl *) 0 ;
32971     bool result;
32972     PyObject * obj0 = 0 ;
32973     char *kwnames[] = {
32974         (char *) "self", NULL
32975     };
32976
32977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_Validate",kwnames,&obj0)) goto fail;
32978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32979     if (SWIG_arg_fail(1)) SWIG_fail;
32980     {
32981         PyThreadState* __tstate = wxPyBeginAllowThreads();
32982         result = (bool)(arg1)->base_Validate();
32983
32984         wxPyEndAllowThreads(__tstate);
32985         if (PyErr_Occurred()) SWIG_fail;
32986     }
32987     {
32988         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32989     }
32990     return resultobj;
32991     fail:
32992     return NULL;
32993 }
32994
32995
32996 static PyObject *_wrap_PyControl_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
32997     PyObject *resultobj;
32998     wxPyControl *arg1 = (wxPyControl *) 0 ;
32999     bool result;
33000     PyObject * obj0 = 0 ;
33001     char *kwnames[] = {
33002         (char *) "self", NULL
33003     };
33004
33005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_AcceptsFocus",kwnames,&obj0)) goto fail;
33006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33007     if (SWIG_arg_fail(1)) SWIG_fail;
33008     {
33009         PyThreadState* __tstate = wxPyBeginAllowThreads();
33010         result = (bool)((wxPyControl const *)arg1)->base_AcceptsFocus();
33011
33012         wxPyEndAllowThreads(__tstate);
33013         if (PyErr_Occurred()) SWIG_fail;
33014     }
33015     {
33016         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33017     }
33018     return resultobj;
33019     fail:
33020     return NULL;
33021 }
33022
33023
33024 static PyObject *_wrap_PyControl_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
33025     PyObject *resultobj;
33026     wxPyControl *arg1 = (wxPyControl *) 0 ;
33027     bool result;
33028     PyObject * obj0 = 0 ;
33029     char *kwnames[] = {
33030         (char *) "self", NULL
33031     };
33032
33033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
33034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33035     if (SWIG_arg_fail(1)) SWIG_fail;
33036     {
33037         PyThreadState* __tstate = wxPyBeginAllowThreads();
33038         result = (bool)((wxPyControl const *)arg1)->base_AcceptsFocusFromKeyboard();
33039
33040         wxPyEndAllowThreads(__tstate);
33041         if (PyErr_Occurred()) SWIG_fail;
33042     }
33043     {
33044         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33045     }
33046     return resultobj;
33047     fail:
33048     return NULL;
33049 }
33050
33051
33052 static PyObject *_wrap_PyControl_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
33053     PyObject *resultobj;
33054     wxPyControl *arg1 = (wxPyControl *) 0 ;
33055     wxSize result;
33056     PyObject * obj0 = 0 ;
33057     char *kwnames[] = {
33058         (char *) "self", NULL
33059     };
33060
33061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_GetMaxSize",kwnames,&obj0)) goto fail;
33062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33063     if (SWIG_arg_fail(1)) SWIG_fail;
33064     {
33065         PyThreadState* __tstate = wxPyBeginAllowThreads();
33066         result = ((wxPyControl const *)arg1)->base_GetMaxSize();
33067
33068         wxPyEndAllowThreads(__tstate);
33069         if (PyErr_Occurred()) SWIG_fail;
33070     }
33071     {
33072         wxSize * resultptr;
33073         resultptr = new wxSize((wxSize &)(result));
33074         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
33075     }
33076     return resultobj;
33077     fail:
33078     return NULL;
33079 }
33080
33081
33082 static PyObject *_wrap_PyControl_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
33083     PyObject *resultobj;
33084     wxPyControl *arg1 = (wxPyControl *) 0 ;
33085     wxWindow *arg2 = (wxWindow *) 0 ;
33086     PyObject * obj0 = 0 ;
33087     PyObject * obj1 = 0 ;
33088     char *kwnames[] = {
33089         (char *) "self",(char *) "child", NULL
33090     };
33091
33092     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
33093     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33094     if (SWIG_arg_fail(1)) SWIG_fail;
33095     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33096     if (SWIG_arg_fail(2)) SWIG_fail;
33097     {
33098         PyThreadState* __tstate = wxPyBeginAllowThreads();
33099         (arg1)->base_AddChild(arg2);
33100
33101         wxPyEndAllowThreads(__tstate);
33102         if (PyErr_Occurred()) SWIG_fail;
33103     }
33104     Py_INCREF(Py_None); resultobj = Py_None;
33105     return resultobj;
33106     fail:
33107     return NULL;
33108 }
33109
33110
33111 static PyObject *_wrap_PyControl_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
33112     PyObject *resultobj;
33113     wxPyControl *arg1 = (wxPyControl *) 0 ;
33114     wxWindow *arg2 = (wxWindow *) 0 ;
33115     PyObject * obj0 = 0 ;
33116     PyObject * obj1 = 0 ;
33117     char *kwnames[] = {
33118         (char *) "self",(char *) "child", NULL
33119     };
33120
33121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
33122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33123     if (SWIG_arg_fail(1)) SWIG_fail;
33124     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33125     if (SWIG_arg_fail(2)) SWIG_fail;
33126     {
33127         PyThreadState* __tstate = wxPyBeginAllowThreads();
33128         (arg1)->base_RemoveChild(arg2);
33129
33130         wxPyEndAllowThreads(__tstate);
33131         if (PyErr_Occurred()) SWIG_fail;
33132     }
33133     Py_INCREF(Py_None); resultobj = Py_None;
33134     return resultobj;
33135     fail:
33136     return NULL;
33137 }
33138
33139
33140 static PyObject *_wrap_PyControl_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
33141     PyObject *resultobj;
33142     wxPyControl *arg1 = (wxPyControl *) 0 ;
33143     bool result;
33144     PyObject * obj0 = 0 ;
33145     char *kwnames[] = {
33146         (char *) "self", NULL
33147     };
33148
33149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
33150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33151     if (SWIG_arg_fail(1)) SWIG_fail;
33152     {
33153         PyThreadState* __tstate = wxPyBeginAllowThreads();
33154         result = (bool)((wxPyControl const *)arg1)->base_ShouldInheritColours();
33155
33156         wxPyEndAllowThreads(__tstate);
33157         if (PyErr_Occurred()) SWIG_fail;
33158     }
33159     {
33160         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33161     }
33162     return resultobj;
33163     fail:
33164     return NULL;
33165 }
33166
33167
33168 static PyObject *_wrap_PyControl_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
33169     PyObject *resultobj;
33170     wxPyControl *arg1 = (wxPyControl *) 0 ;
33171     wxColour *arg2 = 0 ;
33172     wxColour temp2 ;
33173     PyObject * obj0 = 0 ;
33174     PyObject * obj1 = 0 ;
33175     char *kwnames[] = {
33176         (char *) "self",(char *) "c", NULL
33177     };
33178
33179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
33180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33181     if (SWIG_arg_fail(1)) SWIG_fail;
33182     {
33183         arg2 = &temp2;
33184         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
33185     }
33186     {
33187         PyThreadState* __tstate = wxPyBeginAllowThreads();
33188         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
33189
33190         wxPyEndAllowThreads(__tstate);
33191         if (PyErr_Occurred()) SWIG_fail;
33192     }
33193     Py_INCREF(Py_None); resultobj = Py_None;
33194     return resultobj;
33195     fail:
33196     return NULL;
33197 }
33198
33199
33200 static PyObject *_wrap_PyControl_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
33201     PyObject *resultobj;
33202     wxPyControl *arg1 = (wxPyControl *) 0 ;
33203     wxVisualAttributes result;
33204     PyObject * obj0 = 0 ;
33205     char *kwnames[] = {
33206         (char *) "self", NULL
33207     };
33208
33209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
33210     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33211     if (SWIG_arg_fail(1)) SWIG_fail;
33212     {
33213         PyThreadState* __tstate = wxPyBeginAllowThreads();
33214         result = (arg1)->base_GetDefaultAttributes();
33215
33216         wxPyEndAllowThreads(__tstate);
33217         if (PyErr_Occurred()) SWIG_fail;
33218     }
33219     {
33220         wxVisualAttributes * resultptr;
33221         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
33222         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
33223     }
33224     return resultobj;
33225     fail:
33226     return NULL;
33227 }
33228
33229
33230 static PyObject * PyControl_swigregister(PyObject *, PyObject *args) {
33231     PyObject *obj;
33232     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33233     SWIG_TypeClientData(SWIGTYPE_p_wxPyControl, obj);
33234     Py_INCREF(obj);
33235     return Py_BuildValue((char *)"");
33236 }
33237 static PyObject *_wrap_new_HelpEvent(PyObject *, PyObject *args, PyObject *kwargs) {
33238     PyObject *resultobj;
33239     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
33240     int arg2 = (int) 0 ;
33241     wxPoint const &arg3_defvalue = wxDefaultPosition ;
33242     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33243     wxHelpEvent *result;
33244     wxPoint temp3 ;
33245     PyObject * obj0 = 0 ;
33246     PyObject * obj1 = 0 ;
33247     PyObject * obj2 = 0 ;
33248     char *kwnames[] = {
33249         (char *) "type",(char *) "winid",(char *) "pt", NULL
33250     };
33251
33252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_HelpEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
33253     if (obj0) {
33254         {
33255             arg1 = (wxEventType)(SWIG_As_int(obj0));
33256             if (SWIG_arg_fail(1)) SWIG_fail;
33257         }
33258     }
33259     if (obj1) {
33260         {
33261             arg2 = (int)(SWIG_As_int(obj1));
33262             if (SWIG_arg_fail(2)) SWIG_fail;
33263         }
33264     }
33265     if (obj2) {
33266         {
33267             arg3 = &temp3;
33268             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33269         }
33270     }
33271     {
33272         PyThreadState* __tstate = wxPyBeginAllowThreads();
33273         result = (wxHelpEvent *)new wxHelpEvent(arg1,arg2,(wxPoint const &)*arg3);
33274
33275         wxPyEndAllowThreads(__tstate);
33276         if (PyErr_Occurred()) SWIG_fail;
33277     }
33278     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpEvent, 1);
33279     return resultobj;
33280     fail:
33281     return NULL;
33282 }
33283
33284
33285 static PyObject *_wrap_HelpEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33286     PyObject *resultobj;
33287     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33288     wxPoint result;
33289     PyObject * obj0 = 0 ;
33290     char *kwnames[] = {
33291         (char *) "self", NULL
33292     };
33293
33294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetPosition",kwnames,&obj0)) goto fail;
33295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33296     if (SWIG_arg_fail(1)) SWIG_fail;
33297     {
33298         PyThreadState* __tstate = wxPyBeginAllowThreads();
33299         result = ((wxHelpEvent const *)arg1)->GetPosition();
33300
33301         wxPyEndAllowThreads(__tstate);
33302         if (PyErr_Occurred()) SWIG_fail;
33303     }
33304     {
33305         wxPoint * resultptr;
33306         resultptr = new wxPoint((wxPoint const &)(result));
33307         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
33308     }
33309     return resultobj;
33310     fail:
33311     return NULL;
33312 }
33313
33314
33315 static PyObject *_wrap_HelpEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33316     PyObject *resultobj;
33317     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33318     wxPoint *arg2 = 0 ;
33319     wxPoint temp2 ;
33320     PyObject * obj0 = 0 ;
33321     PyObject * obj1 = 0 ;
33322     char *kwnames[] = {
33323         (char *) "self",(char *) "pos", NULL
33324     };
33325
33326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
33327     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33328     if (SWIG_arg_fail(1)) SWIG_fail;
33329     {
33330         arg2 = &temp2;
33331         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33332     }
33333     {
33334         PyThreadState* __tstate = wxPyBeginAllowThreads();
33335         (arg1)->SetPosition((wxPoint const &)*arg2);
33336
33337         wxPyEndAllowThreads(__tstate);
33338         if (PyErr_Occurred()) SWIG_fail;
33339     }
33340     Py_INCREF(Py_None); resultobj = Py_None;
33341     return resultobj;
33342     fail:
33343     return NULL;
33344 }
33345
33346
33347 static PyObject *_wrap_HelpEvent_GetLink(PyObject *, PyObject *args, PyObject *kwargs) {
33348     PyObject *resultobj;
33349     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33350     wxString *result;
33351     PyObject * obj0 = 0 ;
33352     char *kwnames[] = {
33353         (char *) "self", NULL
33354     };
33355
33356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetLink",kwnames,&obj0)) goto fail;
33357     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33358     if (SWIG_arg_fail(1)) SWIG_fail;
33359     {
33360         PyThreadState* __tstate = wxPyBeginAllowThreads();
33361         {
33362             wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetLink();
33363             result = (wxString *) &_result_ref;
33364         }
33365
33366         wxPyEndAllowThreads(__tstate);
33367         if (PyErr_Occurred()) SWIG_fail;
33368     }
33369     {
33370 #if wxUSE_UNICODE
33371         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
33372 #else
33373         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
33374 #endif
33375     }
33376     return resultobj;
33377     fail:
33378     return NULL;
33379 }
33380
33381
33382 static PyObject *_wrap_HelpEvent_SetLink(PyObject *, PyObject *args, PyObject *kwargs) {
33383     PyObject *resultobj;
33384     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33385     wxString *arg2 = 0 ;
33386     bool temp2 = false ;
33387     PyObject * obj0 = 0 ;
33388     PyObject * obj1 = 0 ;
33389     char *kwnames[] = {
33390         (char *) "self",(char *) "link", NULL
33391     };
33392
33393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetLink",kwnames,&obj0,&obj1)) goto fail;
33394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33395     if (SWIG_arg_fail(1)) SWIG_fail;
33396     {
33397         arg2 = wxString_in_helper(obj1);
33398         if (arg2 == NULL) SWIG_fail;
33399         temp2 = true;
33400     }
33401     {
33402         PyThreadState* __tstate = wxPyBeginAllowThreads();
33403         (arg1)->SetLink((wxString const &)*arg2);
33404
33405         wxPyEndAllowThreads(__tstate);
33406         if (PyErr_Occurred()) SWIG_fail;
33407     }
33408     Py_INCREF(Py_None); resultobj = Py_None;
33409     {
33410         if (temp2)
33411         delete arg2;
33412     }
33413     return resultobj;
33414     fail:
33415     {
33416         if (temp2)
33417         delete arg2;
33418     }
33419     return NULL;
33420 }
33421
33422
33423 static PyObject *_wrap_HelpEvent_GetTarget(PyObject *, PyObject *args, PyObject *kwargs) {
33424     PyObject *resultobj;
33425     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33426     wxString *result;
33427     PyObject * obj0 = 0 ;
33428     char *kwnames[] = {
33429         (char *) "self", NULL
33430     };
33431
33432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetTarget",kwnames,&obj0)) goto fail;
33433     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33434     if (SWIG_arg_fail(1)) SWIG_fail;
33435     {
33436         PyThreadState* __tstate = wxPyBeginAllowThreads();
33437         {
33438             wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetTarget();
33439             result = (wxString *) &_result_ref;
33440         }
33441
33442         wxPyEndAllowThreads(__tstate);
33443         if (PyErr_Occurred()) SWIG_fail;
33444     }
33445     {
33446 #if wxUSE_UNICODE
33447         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
33448 #else
33449         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
33450 #endif
33451     }
33452     return resultobj;
33453     fail:
33454     return NULL;
33455 }
33456
33457
33458 static PyObject *_wrap_HelpEvent_SetTarget(PyObject *, PyObject *args, PyObject *kwargs) {
33459     PyObject *resultobj;
33460     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33461     wxString *arg2 = 0 ;
33462     bool temp2 = false ;
33463     PyObject * obj0 = 0 ;
33464     PyObject * obj1 = 0 ;
33465     char *kwnames[] = {
33466         (char *) "self",(char *) "target", NULL
33467     };
33468
33469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetTarget",kwnames,&obj0,&obj1)) goto fail;
33470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33471     if (SWIG_arg_fail(1)) SWIG_fail;
33472     {
33473         arg2 = wxString_in_helper(obj1);
33474         if (arg2 == NULL) SWIG_fail;
33475         temp2 = true;
33476     }
33477     {
33478         PyThreadState* __tstate = wxPyBeginAllowThreads();
33479         (arg1)->SetTarget((wxString const &)*arg2);
33480
33481         wxPyEndAllowThreads(__tstate);
33482         if (PyErr_Occurred()) SWIG_fail;
33483     }
33484     Py_INCREF(Py_None); resultobj = Py_None;
33485     {
33486         if (temp2)
33487         delete arg2;
33488     }
33489     return resultobj;
33490     fail:
33491     {
33492         if (temp2)
33493         delete arg2;
33494     }
33495     return NULL;
33496 }
33497
33498
33499 static PyObject * HelpEvent_swigregister(PyObject *, PyObject *args) {
33500     PyObject *obj;
33501     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33502     SWIG_TypeClientData(SWIGTYPE_p_wxHelpEvent, obj);
33503     Py_INCREF(obj);
33504     return Py_BuildValue((char *)"");
33505 }
33506 static PyObject *_wrap_new_ContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33507     PyObject *resultobj;
33508     wxWindow *arg1 = (wxWindow *) NULL ;
33509     bool arg2 = (bool) true ;
33510     wxContextHelp *result;
33511     PyObject * obj0 = 0 ;
33512     PyObject * obj1 = 0 ;
33513     char *kwnames[] = {
33514         (char *) "window",(char *) "doNow", NULL
33515     };
33516
33517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ContextHelp",kwnames,&obj0,&obj1)) goto fail;
33518     if (obj0) {
33519         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33520         if (SWIG_arg_fail(1)) SWIG_fail;
33521     }
33522     if (obj1) {
33523         {
33524             arg2 = (bool)(SWIG_As_bool(obj1));
33525             if (SWIG_arg_fail(2)) SWIG_fail;
33526         }
33527     }
33528     {
33529         if (!wxPyCheckForApp()) SWIG_fail;
33530         PyThreadState* __tstate = wxPyBeginAllowThreads();
33531         result = (wxContextHelp *)new wxContextHelp(arg1,arg2);
33532
33533         wxPyEndAllowThreads(__tstate);
33534         if (PyErr_Occurred()) SWIG_fail;
33535     }
33536     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextHelp, 1);
33537     return resultobj;
33538     fail:
33539     return NULL;
33540 }
33541
33542
33543 static PyObject *_wrap_delete_ContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33544     PyObject *resultobj;
33545     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33546     PyObject * obj0 = 0 ;
33547     char *kwnames[] = {
33548         (char *) "self", NULL
33549     };
33550
33551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ContextHelp",kwnames,&obj0)) goto fail;
33552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33553     if (SWIG_arg_fail(1)) SWIG_fail;
33554     {
33555         PyThreadState* __tstate = wxPyBeginAllowThreads();
33556         delete arg1;
33557
33558         wxPyEndAllowThreads(__tstate);
33559         if (PyErr_Occurred()) SWIG_fail;
33560     }
33561     Py_INCREF(Py_None); resultobj = Py_None;
33562     return resultobj;
33563     fail:
33564     return NULL;
33565 }
33566
33567
33568 static PyObject *_wrap_ContextHelp_BeginContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33569     PyObject *resultobj;
33570     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33571     wxWindow *arg2 = (wxWindow *) NULL ;
33572     bool result;
33573     PyObject * obj0 = 0 ;
33574     PyObject * obj1 = 0 ;
33575     char *kwnames[] = {
33576         (char *) "self",(char *) "window", NULL
33577     };
33578
33579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ContextHelp_BeginContextHelp",kwnames,&obj0,&obj1)) goto fail;
33580     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33581     if (SWIG_arg_fail(1)) SWIG_fail;
33582     if (obj1) {
33583         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33584         if (SWIG_arg_fail(2)) SWIG_fail;
33585     }
33586     {
33587         PyThreadState* __tstate = wxPyBeginAllowThreads();
33588         result = (bool)(arg1)->BeginContextHelp(arg2);
33589
33590         wxPyEndAllowThreads(__tstate);
33591         if (PyErr_Occurred()) SWIG_fail;
33592     }
33593     {
33594         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33595     }
33596     return resultobj;
33597     fail:
33598     return NULL;
33599 }
33600
33601
33602 static PyObject *_wrap_ContextHelp_EndContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33603     PyObject *resultobj;
33604     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33605     bool result;
33606     PyObject * obj0 = 0 ;
33607     char *kwnames[] = {
33608         (char *) "self", NULL
33609     };
33610
33611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextHelp_EndContextHelp",kwnames,&obj0)) goto fail;
33612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33613     if (SWIG_arg_fail(1)) SWIG_fail;
33614     {
33615         PyThreadState* __tstate = wxPyBeginAllowThreads();
33616         result = (bool)(arg1)->EndContextHelp();
33617
33618         wxPyEndAllowThreads(__tstate);
33619         if (PyErr_Occurred()) SWIG_fail;
33620     }
33621     {
33622         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33623     }
33624     return resultobj;
33625     fail:
33626     return NULL;
33627 }
33628
33629
33630 static PyObject * ContextHelp_swigregister(PyObject *, PyObject *args) {
33631     PyObject *obj;
33632     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33633     SWIG_TypeClientData(SWIGTYPE_p_wxContextHelp, obj);
33634     Py_INCREF(obj);
33635     return Py_BuildValue((char *)"");
33636 }
33637 static PyObject *_wrap_new_ContextHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
33638     PyObject *resultobj;
33639     wxWindow *arg1 = (wxWindow *) 0 ;
33640     int arg2 = (int) wxID_CONTEXT_HELP ;
33641     wxPoint const &arg3_defvalue = wxDefaultPosition ;
33642     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33643     wxSize const &arg4_defvalue = wxDefaultSize ;
33644     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33645     long arg5 = (long) wxBU_AUTODRAW ;
33646     wxContextHelpButton *result;
33647     wxPoint temp3 ;
33648     wxSize temp4 ;
33649     PyObject * obj0 = 0 ;
33650     PyObject * obj1 = 0 ;
33651     PyObject * obj2 = 0 ;
33652     PyObject * obj3 = 0 ;
33653     PyObject * obj4 = 0 ;
33654     char *kwnames[] = {
33655         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
33656     };
33657
33658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_ContextHelpButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33660     if (SWIG_arg_fail(1)) SWIG_fail;
33661     if (obj1) {
33662         {
33663             arg2 = (int)(SWIG_As_int(obj1));
33664             if (SWIG_arg_fail(2)) SWIG_fail;
33665         }
33666     }
33667     if (obj2) {
33668         {
33669             arg3 = &temp3;
33670             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33671         }
33672     }
33673     if (obj3) {
33674         {
33675             arg4 = &temp4;
33676             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33677         }
33678     }
33679     if (obj4) {
33680         {
33681             arg5 = (long)(SWIG_As_long(obj4));
33682             if (SWIG_arg_fail(5)) SWIG_fail;
33683         }
33684     }
33685     {
33686         if (!wxPyCheckForApp()) SWIG_fail;
33687         PyThreadState* __tstate = wxPyBeginAllowThreads();
33688         result = (wxContextHelpButton *)new wxContextHelpButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
33689
33690         wxPyEndAllowThreads(__tstate);
33691         if (PyErr_Occurred()) SWIG_fail;
33692     }
33693     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextHelpButton, 1);
33694     return resultobj;
33695     fail:
33696     return NULL;
33697 }
33698
33699
33700 static PyObject * ContextHelpButton_swigregister(PyObject *, PyObject *args) {
33701     PyObject *obj;
33702     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33703     SWIG_TypeClientData(SWIGTYPE_p_wxContextHelpButton, obj);
33704     Py_INCREF(obj);
33705     return Py_BuildValue((char *)"");
33706 }
33707 static PyObject *_wrap_HelpProvider_Set(PyObject *, PyObject *args, PyObject *kwargs) {
33708     PyObject *resultobj;
33709     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33710     wxHelpProvider *result;
33711     PyObject * obj0 = 0 ;
33712     char *kwnames[] = {
33713         (char *) "helpProvider", NULL
33714     };
33715
33716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpProvider_Set",kwnames,&obj0)) goto fail;
33717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33718     if (SWIG_arg_fail(1)) SWIG_fail;
33719     {
33720         PyThreadState* __tstate = wxPyBeginAllowThreads();
33721         result = (wxHelpProvider *)wxHelpProvider::Set(arg1);
33722
33723         wxPyEndAllowThreads(__tstate);
33724         if (PyErr_Occurred()) SWIG_fail;
33725     }
33726     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpProvider, 0);
33727     return resultobj;
33728     fail:
33729     return NULL;
33730 }
33731
33732
33733 static PyObject *_wrap_HelpProvider_Get(PyObject *, PyObject *args, PyObject *kwargs) {
33734     PyObject *resultobj;
33735     wxHelpProvider *result;
33736     char *kwnames[] = {
33737         NULL
33738     };
33739
33740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":HelpProvider_Get",kwnames)) goto fail;
33741     {
33742         PyThreadState* __tstate = wxPyBeginAllowThreads();
33743         result = (wxHelpProvider *)wxHelpProvider::Get();
33744
33745         wxPyEndAllowThreads(__tstate);
33746         if (PyErr_Occurred()) SWIG_fail;
33747     }
33748     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpProvider, 0);
33749     return resultobj;
33750     fail:
33751     return NULL;
33752 }
33753
33754
33755 static PyObject *_wrap_HelpProvider_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33756     PyObject *resultobj;
33757     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33758     wxWindow *arg2 = (wxWindow *) 0 ;
33759     wxString result;
33760     PyObject * obj0 = 0 ;
33761     PyObject * obj1 = 0 ;
33762     char *kwnames[] = {
33763         (char *) "self",(char *) "window", NULL
33764     };
33765
33766     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_GetHelp",kwnames,&obj0,&obj1)) goto fail;
33767     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33768     if (SWIG_arg_fail(1)) SWIG_fail;
33769     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33770     if (SWIG_arg_fail(2)) SWIG_fail;
33771     {
33772         PyThreadState* __tstate = wxPyBeginAllowThreads();
33773         result = (arg1)->GetHelp((wxWindow const *)arg2);
33774
33775         wxPyEndAllowThreads(__tstate);
33776         if (PyErr_Occurred()) SWIG_fail;
33777     }
33778     {
33779 #if wxUSE_UNICODE
33780         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33781 #else
33782         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33783 #endif
33784     }
33785     return resultobj;
33786     fail:
33787     return NULL;
33788 }
33789
33790
33791 static PyObject *_wrap_HelpProvider_ShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33792     PyObject *resultobj;
33793     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33794     wxWindow *arg2 = (wxWindow *) 0 ;
33795     bool result;
33796     PyObject * obj0 = 0 ;
33797     PyObject * obj1 = 0 ;
33798     char *kwnames[] = {
33799         (char *) "self",(char *) "window", NULL
33800     };
33801
33802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_ShowHelp",kwnames,&obj0,&obj1)) goto fail;
33803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33804     if (SWIG_arg_fail(1)) SWIG_fail;
33805     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33806     if (SWIG_arg_fail(2)) SWIG_fail;
33807     {
33808         PyThreadState* __tstate = wxPyBeginAllowThreads();
33809         result = (bool)(arg1)->ShowHelp(arg2);
33810
33811         wxPyEndAllowThreads(__tstate);
33812         if (PyErr_Occurred()) SWIG_fail;
33813     }
33814     {
33815         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33816     }
33817     return resultobj;
33818     fail:
33819     return NULL;
33820 }
33821
33822
33823 static PyObject *_wrap_HelpProvider_AddHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33824     PyObject *resultobj;
33825     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33826     wxWindow *arg2 = (wxWindow *) 0 ;
33827     wxString *arg3 = 0 ;
33828     bool temp3 = false ;
33829     PyObject * obj0 = 0 ;
33830     PyObject * obj1 = 0 ;
33831     PyObject * obj2 = 0 ;
33832     char *kwnames[] = {
33833         (char *) "self",(char *) "window",(char *) "text", NULL
33834     };
33835
33836     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
33837     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33838     if (SWIG_arg_fail(1)) SWIG_fail;
33839     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33840     if (SWIG_arg_fail(2)) SWIG_fail;
33841     {
33842         arg3 = wxString_in_helper(obj2);
33843         if (arg3 == NULL) SWIG_fail;
33844         temp3 = true;
33845     }
33846     {
33847         PyThreadState* __tstate = wxPyBeginAllowThreads();
33848         (arg1)->AddHelp(arg2,(wxString const &)*arg3);
33849
33850         wxPyEndAllowThreads(__tstate);
33851         if (PyErr_Occurred()) SWIG_fail;
33852     }
33853     Py_INCREF(Py_None); resultobj = Py_None;
33854     {
33855         if (temp3)
33856         delete arg3;
33857     }
33858     return resultobj;
33859     fail:
33860     {
33861         if (temp3)
33862         delete arg3;
33863     }
33864     return NULL;
33865 }
33866
33867
33868 static PyObject *_wrap_HelpProvider_AddHelpById(PyObject *, PyObject *args, PyObject *kwargs) {
33869     PyObject *resultobj;
33870     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33871     int arg2 ;
33872     wxString *arg3 = 0 ;
33873     bool temp3 = false ;
33874     PyObject * obj0 = 0 ;
33875     PyObject * obj1 = 0 ;
33876     PyObject * obj2 = 0 ;
33877     char *kwnames[] = {
33878         (char *) "self",(char *) "id",(char *) "text", NULL
33879     };
33880
33881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelpById",kwnames,&obj0,&obj1,&obj2)) goto fail;
33882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33883     if (SWIG_arg_fail(1)) SWIG_fail;
33884     {
33885         arg2 = (int)(SWIG_As_int(obj1));
33886         if (SWIG_arg_fail(2)) SWIG_fail;
33887     }
33888     {
33889         arg3 = wxString_in_helper(obj2);
33890         if (arg3 == NULL) SWIG_fail;
33891         temp3 = true;
33892     }
33893     {
33894         PyThreadState* __tstate = wxPyBeginAllowThreads();
33895         (arg1)->AddHelp(arg2,(wxString const &)*arg3);
33896
33897         wxPyEndAllowThreads(__tstate);
33898         if (PyErr_Occurred()) SWIG_fail;
33899     }
33900     Py_INCREF(Py_None); resultobj = Py_None;
33901     {
33902         if (temp3)
33903         delete arg3;
33904     }
33905     return resultobj;
33906     fail:
33907     {
33908         if (temp3)
33909         delete arg3;
33910     }
33911     return NULL;
33912 }
33913
33914
33915 static PyObject *_wrap_HelpProvider_RemoveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33916     PyObject *resultobj;
33917     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33918     wxWindow *arg2 = (wxWindow *) 0 ;
33919     PyObject * obj0 = 0 ;
33920     PyObject * obj1 = 0 ;
33921     char *kwnames[] = {
33922         (char *) "self",(char *) "window", NULL
33923     };
33924
33925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_RemoveHelp",kwnames,&obj0,&obj1)) goto fail;
33926     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33927     if (SWIG_arg_fail(1)) SWIG_fail;
33928     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33929     if (SWIG_arg_fail(2)) SWIG_fail;
33930     {
33931         PyThreadState* __tstate = wxPyBeginAllowThreads();
33932         (arg1)->RemoveHelp(arg2);
33933
33934         wxPyEndAllowThreads(__tstate);
33935         if (PyErr_Occurred()) SWIG_fail;
33936     }
33937     Py_INCREF(Py_None); resultobj = Py_None;
33938     return resultobj;
33939     fail:
33940     return NULL;
33941 }
33942
33943
33944 static PyObject *_wrap_HelpProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33945     PyObject *resultobj;
33946     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33947     PyObject * obj0 = 0 ;
33948     char *kwnames[] = {
33949         (char *) "self", NULL
33950     };
33951
33952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpProvider_Destroy",kwnames,&obj0)) goto fail;
33953     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33954     if (SWIG_arg_fail(1)) SWIG_fail;
33955     {
33956         PyThreadState* __tstate = wxPyBeginAllowThreads();
33957         wxHelpProvider_Destroy(arg1);
33958
33959         wxPyEndAllowThreads(__tstate);
33960         if (PyErr_Occurred()) SWIG_fail;
33961     }
33962     Py_INCREF(Py_None); resultobj = Py_None;
33963     return resultobj;
33964     fail:
33965     return NULL;
33966 }
33967
33968
33969 static PyObject * HelpProvider_swigregister(PyObject *, PyObject *args) {
33970     PyObject *obj;
33971     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33972     SWIG_TypeClientData(SWIGTYPE_p_wxHelpProvider, obj);
33973     Py_INCREF(obj);
33974     return Py_BuildValue((char *)"");
33975 }
33976 static PyObject *_wrap_new_SimpleHelpProvider(PyObject *, PyObject *args, PyObject *kwargs) {
33977     PyObject *resultobj;
33978     wxSimpleHelpProvider *result;
33979     char *kwnames[] = {
33980         NULL
33981     };
33982
33983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SimpleHelpProvider",kwnames)) goto fail;
33984     {
33985         PyThreadState* __tstate = wxPyBeginAllowThreads();
33986         result = (wxSimpleHelpProvider *)new wxSimpleHelpProvider();
33987
33988         wxPyEndAllowThreads(__tstate);
33989         if (PyErr_Occurred()) SWIG_fail;
33990     }
33991     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSimpleHelpProvider, 1);
33992     return resultobj;
33993     fail:
33994     return NULL;
33995 }
33996
33997
33998 static PyObject * SimpleHelpProvider_swigregister(PyObject *, PyObject *args) {
33999     PyObject *obj;
34000     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34001     SWIG_TypeClientData(SWIGTYPE_p_wxSimpleHelpProvider, obj);
34002     Py_INCREF(obj);
34003     return Py_BuildValue((char *)"");
34004 }
34005 static PyObject *_wrap_new_DragImage(PyObject *, PyObject *args, PyObject *kwargs) {
34006     PyObject *resultobj;
34007     wxBitmap *arg1 = 0 ;
34008     wxCursor const &arg2_defvalue = wxNullCursor ;
34009     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34010     wxGenericDragImage *result;
34011     PyObject * obj0 = 0 ;
34012     PyObject * obj1 = 0 ;
34013     char *kwnames[] = {
34014         (char *) "image",(char *) "cursor", NULL
34015     };
34016
34017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragImage",kwnames,&obj0,&obj1)) goto fail;
34018     {
34019         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
34020         if (SWIG_arg_fail(1)) SWIG_fail;
34021         if (arg1 == NULL) {
34022             SWIG_null_ref("wxBitmap");
34023         }
34024         if (SWIG_arg_fail(1)) SWIG_fail;
34025     }
34026     if (obj1) {
34027         {
34028             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34029             if (SWIG_arg_fail(2)) SWIG_fail;
34030             if (arg2 == NULL) {
34031                 SWIG_null_ref("wxCursor");
34032             }
34033             if (SWIG_arg_fail(2)) SWIG_fail;
34034         }
34035     }
34036     {
34037         if (!wxPyCheckForApp()) SWIG_fail;
34038         PyThreadState* __tstate = wxPyBeginAllowThreads();
34039         result = (wxGenericDragImage *)new wxGenericDragImage((wxBitmap const &)*arg1,(wxCursor const &)*arg2);
34040
34041         wxPyEndAllowThreads(__tstate);
34042         if (PyErr_Occurred()) SWIG_fail;
34043     }
34044     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34045     return resultobj;
34046     fail:
34047     return NULL;
34048 }
34049
34050
34051 static PyObject *_wrap_new_DragIcon(PyObject *, PyObject *args, PyObject *kwargs) {
34052     PyObject *resultobj;
34053     wxIcon *arg1 = 0 ;
34054     wxCursor const &arg2_defvalue = wxNullCursor ;
34055     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34056     wxGenericDragImage *result;
34057     PyObject * obj0 = 0 ;
34058     PyObject * obj1 = 0 ;
34059     char *kwnames[] = {
34060         (char *) "image",(char *) "cursor", NULL
34061     };
34062
34063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragIcon",kwnames,&obj0,&obj1)) goto fail;
34064     {
34065         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
34066         if (SWIG_arg_fail(1)) SWIG_fail;
34067         if (arg1 == NULL) {
34068             SWIG_null_ref("wxIcon");
34069         }
34070         if (SWIG_arg_fail(1)) SWIG_fail;
34071     }
34072     if (obj1) {
34073         {
34074             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34075             if (SWIG_arg_fail(2)) SWIG_fail;
34076             if (arg2 == NULL) {
34077                 SWIG_null_ref("wxCursor");
34078             }
34079             if (SWIG_arg_fail(2)) SWIG_fail;
34080         }
34081     }
34082     {
34083         if (!wxPyCheckForApp()) SWIG_fail;
34084         PyThreadState* __tstate = wxPyBeginAllowThreads();
34085         result = (wxGenericDragImage *)new wxGenericDragImage((wxIcon const &)*arg1,(wxCursor const &)*arg2);
34086
34087         wxPyEndAllowThreads(__tstate);
34088         if (PyErr_Occurred()) SWIG_fail;
34089     }
34090     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34091     return resultobj;
34092     fail:
34093     return NULL;
34094 }
34095
34096
34097 static PyObject *_wrap_new_DragString(PyObject *, PyObject *args, PyObject *kwargs) {
34098     PyObject *resultobj;
34099     wxString *arg1 = 0 ;
34100     wxCursor const &arg2_defvalue = wxNullCursor ;
34101     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34102     wxGenericDragImage *result;
34103     bool temp1 = false ;
34104     PyObject * obj0 = 0 ;
34105     PyObject * obj1 = 0 ;
34106     char *kwnames[] = {
34107         (char *) "str",(char *) "cursor", NULL
34108     };
34109
34110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragString",kwnames,&obj0,&obj1)) goto fail;
34111     {
34112         arg1 = wxString_in_helper(obj0);
34113         if (arg1 == NULL) SWIG_fail;
34114         temp1 = true;
34115     }
34116     if (obj1) {
34117         {
34118             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34119             if (SWIG_arg_fail(2)) SWIG_fail;
34120             if (arg2 == NULL) {
34121                 SWIG_null_ref("wxCursor");
34122             }
34123             if (SWIG_arg_fail(2)) SWIG_fail;
34124         }
34125     }
34126     {
34127         if (!wxPyCheckForApp()) SWIG_fail;
34128         PyThreadState* __tstate = wxPyBeginAllowThreads();
34129         result = (wxGenericDragImage *)new wxGenericDragImage((wxString const &)*arg1,(wxCursor const &)*arg2);
34130
34131         wxPyEndAllowThreads(__tstate);
34132         if (PyErr_Occurred()) SWIG_fail;
34133     }
34134     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34135     {
34136         if (temp1)
34137         delete arg1;
34138     }
34139     return resultobj;
34140     fail:
34141     {
34142         if (temp1)
34143         delete arg1;
34144     }
34145     return NULL;
34146 }
34147
34148
34149 static PyObject *_wrap_new_DragTreeItem(PyObject *, PyObject *args, PyObject *kwargs) {
34150     PyObject *resultobj;
34151     wxPyTreeCtrl *arg1 = 0 ;
34152     wxTreeItemId *arg2 = 0 ;
34153     wxGenericDragImage *result;
34154     PyObject * obj0 = 0 ;
34155     PyObject * obj1 = 0 ;
34156     char *kwnames[] = {
34157         (char *) "treeCtrl",(char *) "id", NULL
34158     };
34159
34160     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragTreeItem",kwnames,&obj0,&obj1)) goto fail;
34161     {
34162         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
34163         if (SWIG_arg_fail(1)) SWIG_fail;
34164         if (arg1 == NULL) {
34165             SWIG_null_ref("wxPyTreeCtrl");
34166         }
34167         if (SWIG_arg_fail(1)) SWIG_fail;
34168     }
34169     {
34170         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
34171         if (SWIG_arg_fail(2)) SWIG_fail;
34172         if (arg2 == NULL) {
34173             SWIG_null_ref("wxTreeItemId");
34174         }
34175         if (SWIG_arg_fail(2)) SWIG_fail;
34176     }
34177     {
34178         if (!wxPyCheckForApp()) SWIG_fail;
34179         PyThreadState* __tstate = wxPyBeginAllowThreads();
34180         result = (wxGenericDragImage *)new wxGenericDragImage((wxPyTreeCtrl const &)*arg1,*arg2);
34181
34182         wxPyEndAllowThreads(__tstate);
34183         if (PyErr_Occurred()) SWIG_fail;
34184     }
34185     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34186     return resultobj;
34187     fail:
34188     return NULL;
34189 }
34190
34191
34192 static PyObject *_wrap_new_DragListItem(PyObject *, PyObject *args, PyObject *kwargs) {
34193     PyObject *resultobj;
34194     wxPyListCtrl *arg1 = 0 ;
34195     long arg2 ;
34196     wxGenericDragImage *result;
34197     PyObject * obj0 = 0 ;
34198     PyObject * obj1 = 0 ;
34199     char *kwnames[] = {
34200         (char *) "listCtrl",(char *) "id", NULL
34201     };
34202
34203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragListItem",kwnames,&obj0,&obj1)) goto fail;
34204     {
34205         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
34206         if (SWIG_arg_fail(1)) SWIG_fail;
34207         if (arg1 == NULL) {
34208             SWIG_null_ref("wxPyListCtrl");
34209         }
34210         if (SWIG_arg_fail(1)) SWIG_fail;
34211     }
34212     {
34213         arg2 = (long)(SWIG_As_long(obj1));
34214         if (SWIG_arg_fail(2)) SWIG_fail;
34215     }
34216     {
34217         if (!wxPyCheckForApp()) SWIG_fail;
34218         PyThreadState* __tstate = wxPyBeginAllowThreads();
34219         result = (wxGenericDragImage *)new wxGenericDragImage((wxPyListCtrl const &)*arg1,arg2);
34220
34221         wxPyEndAllowThreads(__tstate);
34222         if (PyErr_Occurred()) SWIG_fail;
34223     }
34224     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34225     return resultobj;
34226     fail:
34227     return NULL;
34228 }
34229
34230
34231 static PyObject *_wrap_delete_DragImage(PyObject *, PyObject *args, PyObject *kwargs) {
34232     PyObject *resultobj;
34233     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34234     PyObject * obj0 = 0 ;
34235     char *kwnames[] = {
34236         (char *) "self", NULL
34237     };
34238
34239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DragImage",kwnames,&obj0)) goto fail;
34240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34241     if (SWIG_arg_fail(1)) SWIG_fail;
34242     {
34243         PyThreadState* __tstate = wxPyBeginAllowThreads();
34244         delete arg1;
34245
34246         wxPyEndAllowThreads(__tstate);
34247         if (PyErr_Occurred()) SWIG_fail;
34248     }
34249     Py_INCREF(Py_None); resultobj = Py_None;
34250     return resultobj;
34251     fail:
34252     return NULL;
34253 }
34254
34255
34256 static PyObject *_wrap_DragImage_SetBackingBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
34257     PyObject *resultobj;
34258     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34259     wxBitmap *arg2 = (wxBitmap *) 0 ;
34260     PyObject * obj0 = 0 ;
34261     PyObject * obj1 = 0 ;
34262     char *kwnames[] = {
34263         (char *) "self",(char *) "bitmap", NULL
34264     };
34265
34266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_SetBackingBitmap",kwnames,&obj0,&obj1)) goto fail;
34267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34268     if (SWIG_arg_fail(1)) SWIG_fail;
34269     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
34270     if (SWIG_arg_fail(2)) SWIG_fail;
34271     {
34272         PyThreadState* __tstate = wxPyBeginAllowThreads();
34273         (arg1)->SetBackingBitmap(arg2);
34274
34275         wxPyEndAllowThreads(__tstate);
34276         if (PyErr_Occurred()) SWIG_fail;
34277     }
34278     Py_INCREF(Py_None); resultobj = Py_None;
34279     return resultobj;
34280     fail:
34281     return NULL;
34282 }
34283
34284
34285 static PyObject *_wrap_DragImage_BeginDrag(PyObject *, PyObject *args, PyObject *kwargs) {
34286     PyObject *resultobj;
34287     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34288     wxPoint *arg2 = 0 ;
34289     wxWindow *arg3 = (wxWindow *) 0 ;
34290     bool arg4 = (bool) false ;
34291     wxRect *arg5 = (wxRect *) NULL ;
34292     bool result;
34293     wxPoint temp2 ;
34294     PyObject * obj0 = 0 ;
34295     PyObject * obj1 = 0 ;
34296     PyObject * obj2 = 0 ;
34297     PyObject * obj3 = 0 ;
34298     PyObject * obj4 = 0 ;
34299     char *kwnames[] = {
34300         (char *) "self",(char *) "hotspot",(char *) "window",(char *) "fullScreen",(char *) "rect", NULL
34301     };
34302
34303     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DragImage_BeginDrag",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34304     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34305     if (SWIG_arg_fail(1)) SWIG_fail;
34306     {
34307         arg2 = &temp2;
34308         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34309     }
34310     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34311     if (SWIG_arg_fail(3)) SWIG_fail;
34312     if (obj3) {
34313         {
34314             arg4 = (bool)(SWIG_As_bool(obj3));
34315             if (SWIG_arg_fail(4)) SWIG_fail;
34316         }
34317     }
34318     if (obj4) {
34319         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
34320         if (SWIG_arg_fail(5)) SWIG_fail;
34321     }
34322     {
34323         PyThreadState* __tstate = wxPyBeginAllowThreads();
34324         result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4,arg5);
34325
34326         wxPyEndAllowThreads(__tstate);
34327         if (PyErr_Occurred()) SWIG_fail;
34328     }
34329     {
34330         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34331     }
34332     return resultobj;
34333     fail:
34334     return NULL;
34335 }
34336
34337
34338 static PyObject *_wrap_DragImage_BeginDragBounded(PyObject *, PyObject *args, PyObject *kwargs) {
34339     PyObject *resultobj;
34340     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34341     wxPoint *arg2 = 0 ;
34342     wxWindow *arg3 = (wxWindow *) 0 ;
34343     wxWindow *arg4 = (wxWindow *) 0 ;
34344     bool result;
34345     wxPoint temp2 ;
34346     PyObject * obj0 = 0 ;
34347     PyObject * obj1 = 0 ;
34348     PyObject * obj2 = 0 ;
34349     PyObject * obj3 = 0 ;
34350     char *kwnames[] = {
34351         (char *) "self",(char *) "hotspot",(char *) "window",(char *) "boundingWindow", NULL
34352     };
34353
34354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DragImage_BeginDragBounded",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34356     if (SWIG_arg_fail(1)) SWIG_fail;
34357     {
34358         arg2 = &temp2;
34359         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34360     }
34361     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34362     if (SWIG_arg_fail(3)) SWIG_fail;
34363     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34364     if (SWIG_arg_fail(4)) SWIG_fail;
34365     {
34366         PyThreadState* __tstate = wxPyBeginAllowThreads();
34367         result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4);
34368
34369         wxPyEndAllowThreads(__tstate);
34370         if (PyErr_Occurred()) SWIG_fail;
34371     }
34372     {
34373         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34374     }
34375     return resultobj;
34376     fail:
34377     return NULL;
34378 }
34379
34380
34381 static PyObject *_wrap_DragImage_EndDrag(PyObject *, PyObject *args, PyObject *kwargs) {
34382     PyObject *resultobj;
34383     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34384     bool result;
34385     PyObject * obj0 = 0 ;
34386     char *kwnames[] = {
34387         (char *) "self", NULL
34388     };
34389
34390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_EndDrag",kwnames,&obj0)) goto fail;
34391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34392     if (SWIG_arg_fail(1)) SWIG_fail;
34393     {
34394         PyThreadState* __tstate = wxPyBeginAllowThreads();
34395         result = (bool)(arg1)->EndDrag();
34396
34397         wxPyEndAllowThreads(__tstate);
34398         if (PyErr_Occurred()) SWIG_fail;
34399     }
34400     {
34401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34402     }
34403     return resultobj;
34404     fail:
34405     return NULL;
34406 }
34407
34408
34409 static PyObject *_wrap_DragImage_Move(PyObject *, PyObject *args, PyObject *kwargs) {
34410     PyObject *resultobj;
34411     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34412     wxPoint *arg2 = 0 ;
34413     bool result;
34414     wxPoint temp2 ;
34415     PyObject * obj0 = 0 ;
34416     PyObject * obj1 = 0 ;
34417     char *kwnames[] = {
34418         (char *) "self",(char *) "pt", NULL
34419     };
34420
34421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_Move",kwnames,&obj0,&obj1)) goto fail;
34422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34423     if (SWIG_arg_fail(1)) SWIG_fail;
34424     {
34425         arg2 = &temp2;
34426         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34427     }
34428     {
34429         PyThreadState* __tstate = wxPyBeginAllowThreads();
34430         result = (bool)(arg1)->Move((wxPoint const &)*arg2);
34431
34432         wxPyEndAllowThreads(__tstate);
34433         if (PyErr_Occurred()) SWIG_fail;
34434     }
34435     {
34436         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34437     }
34438     return resultobj;
34439     fail:
34440     return NULL;
34441 }
34442
34443
34444 static PyObject *_wrap_DragImage_Show(PyObject *, PyObject *args, PyObject *kwargs) {
34445     PyObject *resultobj;
34446     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34447     bool result;
34448     PyObject * obj0 = 0 ;
34449     char *kwnames[] = {
34450         (char *) "self", NULL
34451     };
34452
34453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_Show",kwnames,&obj0)) goto fail;
34454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34455     if (SWIG_arg_fail(1)) SWIG_fail;
34456     {
34457         PyThreadState* __tstate = wxPyBeginAllowThreads();
34458         result = (bool)(arg1)->Show();
34459
34460         wxPyEndAllowThreads(__tstate);
34461         if (PyErr_Occurred()) SWIG_fail;
34462     }
34463     {
34464         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34465     }
34466     return resultobj;
34467     fail:
34468     return NULL;
34469 }
34470
34471
34472 static PyObject *_wrap_DragImage_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
34473     PyObject *resultobj;
34474     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34475     bool result;
34476     PyObject * obj0 = 0 ;
34477     char *kwnames[] = {
34478         (char *) "self", NULL
34479     };
34480
34481     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_Hide",kwnames,&obj0)) goto fail;
34482     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34483     if (SWIG_arg_fail(1)) SWIG_fail;
34484     {
34485         PyThreadState* __tstate = wxPyBeginAllowThreads();
34486         result = (bool)(arg1)->Hide();
34487
34488         wxPyEndAllowThreads(__tstate);
34489         if (PyErr_Occurred()) SWIG_fail;
34490     }
34491     {
34492         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34493     }
34494     return resultobj;
34495     fail:
34496     return NULL;
34497 }
34498
34499
34500 static PyObject *_wrap_DragImage_GetImageRect(PyObject *, PyObject *args, PyObject *kwargs) {
34501     PyObject *resultobj;
34502     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34503     wxPoint *arg2 = 0 ;
34504     wxRect result;
34505     wxPoint temp2 ;
34506     PyObject * obj0 = 0 ;
34507     PyObject * obj1 = 0 ;
34508     char *kwnames[] = {
34509         (char *) "self",(char *) "pos", NULL
34510     };
34511
34512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_GetImageRect",kwnames,&obj0,&obj1)) goto fail;
34513     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34514     if (SWIG_arg_fail(1)) SWIG_fail;
34515     {
34516         arg2 = &temp2;
34517         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34518     }
34519     {
34520         PyThreadState* __tstate = wxPyBeginAllowThreads();
34521         result = ((wxGenericDragImage const *)arg1)->GetImageRect((wxPoint const &)*arg2);
34522
34523         wxPyEndAllowThreads(__tstate);
34524         if (PyErr_Occurred()) SWIG_fail;
34525     }
34526     {
34527         wxRect * resultptr;
34528         resultptr = new wxRect((wxRect &)(result));
34529         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
34530     }
34531     return resultobj;
34532     fail:
34533     return NULL;
34534 }
34535
34536
34537 static PyObject *_wrap_DragImage_DoDrawImage(PyObject *, PyObject *args, PyObject *kwargs) {
34538     PyObject *resultobj;
34539     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34540     wxDC *arg2 = 0 ;
34541     wxPoint *arg3 = 0 ;
34542     bool result;
34543     wxPoint temp3 ;
34544     PyObject * obj0 = 0 ;
34545     PyObject * obj1 = 0 ;
34546     PyObject * obj2 = 0 ;
34547     char *kwnames[] = {
34548         (char *) "self",(char *) "dc",(char *) "pos", NULL
34549     };
34550
34551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DragImage_DoDrawImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
34552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34553     if (SWIG_arg_fail(1)) SWIG_fail;
34554     {
34555         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
34556         if (SWIG_arg_fail(2)) SWIG_fail;
34557         if (arg2 == NULL) {
34558             SWIG_null_ref("wxDC");
34559         }
34560         if (SWIG_arg_fail(2)) SWIG_fail;
34561     }
34562     {
34563         arg3 = &temp3;
34564         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
34565     }
34566     {
34567         PyThreadState* __tstate = wxPyBeginAllowThreads();
34568         result = (bool)((wxGenericDragImage const *)arg1)->DoDrawImage(*arg2,(wxPoint const &)*arg3);
34569
34570         wxPyEndAllowThreads(__tstate);
34571         if (PyErr_Occurred()) SWIG_fail;
34572     }
34573     {
34574         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34575     }
34576     return resultobj;
34577     fail:
34578     return NULL;
34579 }
34580
34581
34582 static PyObject *_wrap_DragImage_UpdateBackingFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34583     PyObject *resultobj;
34584     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34585     wxDC *arg2 = 0 ;
34586     wxMemoryDC *arg3 = 0 ;
34587     wxRect *arg4 = 0 ;
34588     wxRect *arg5 = 0 ;
34589     bool result;
34590     wxRect temp4 ;
34591     wxRect temp5 ;
34592     PyObject * obj0 = 0 ;
34593     PyObject * obj1 = 0 ;
34594     PyObject * obj2 = 0 ;
34595     PyObject * obj3 = 0 ;
34596     PyObject * obj4 = 0 ;
34597     char *kwnames[] = {
34598         (char *) "self",(char *) "windowDC",(char *) "destDC",(char *) "sourceRect",(char *) "destRect", NULL
34599     };
34600
34601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_UpdateBackingFromWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34603     if (SWIG_arg_fail(1)) SWIG_fail;
34604     {
34605         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
34606         if (SWIG_arg_fail(2)) SWIG_fail;
34607         if (arg2 == NULL) {
34608             SWIG_null_ref("wxDC");
34609         }
34610         if (SWIG_arg_fail(2)) SWIG_fail;
34611     }
34612     {
34613         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
34614         if (SWIG_arg_fail(3)) SWIG_fail;
34615         if (arg3 == NULL) {
34616             SWIG_null_ref("wxMemoryDC");
34617         }
34618         if (SWIG_arg_fail(3)) SWIG_fail;
34619     }
34620     {
34621         arg4 = &temp4;
34622         if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
34623     }
34624     {
34625         arg5 = &temp5;
34626         if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
34627     }
34628     {
34629         PyThreadState* __tstate = wxPyBeginAllowThreads();
34630         result = (bool)((wxGenericDragImage const *)arg1)->UpdateBackingFromWindow(*arg2,*arg3,(wxRect const &)*arg4,(wxRect const &)*arg5);
34631
34632         wxPyEndAllowThreads(__tstate);
34633         if (PyErr_Occurred()) SWIG_fail;
34634     }
34635     {
34636         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34637     }
34638     return resultobj;
34639     fail:
34640     return NULL;
34641 }
34642
34643
34644 static PyObject *_wrap_DragImage_RedrawImage(PyObject *, PyObject *args, PyObject *kwargs) {
34645     PyObject *resultobj;
34646     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34647     wxPoint *arg2 = 0 ;
34648     wxPoint *arg3 = 0 ;
34649     bool arg4 ;
34650     bool arg5 ;
34651     bool result;
34652     wxPoint temp2 ;
34653     wxPoint temp3 ;
34654     PyObject * obj0 = 0 ;
34655     PyObject * obj1 = 0 ;
34656     PyObject * obj2 = 0 ;
34657     PyObject * obj3 = 0 ;
34658     PyObject * obj4 = 0 ;
34659     char *kwnames[] = {
34660         (char *) "self",(char *) "oldPos",(char *) "newPos",(char *) "eraseOld",(char *) "drawNew", NULL
34661     };
34662
34663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_RedrawImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34665     if (SWIG_arg_fail(1)) SWIG_fail;
34666     {
34667         arg2 = &temp2;
34668         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34669     }
34670     {
34671         arg3 = &temp3;
34672         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
34673     }
34674     {
34675         arg4 = (bool)(SWIG_As_bool(obj3));
34676         if (SWIG_arg_fail(4)) SWIG_fail;
34677     }
34678     {
34679         arg5 = (bool)(SWIG_As_bool(obj4));
34680         if (SWIG_arg_fail(5)) SWIG_fail;
34681     }
34682     {
34683         PyThreadState* __tstate = wxPyBeginAllowThreads();
34684         result = (bool)(arg1)->RedrawImage((wxPoint const &)*arg2,(wxPoint const &)*arg3,arg4,arg5);
34685
34686         wxPyEndAllowThreads(__tstate);
34687         if (PyErr_Occurred()) SWIG_fail;
34688     }
34689     {
34690         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34691     }
34692     return resultobj;
34693     fail:
34694     return NULL;
34695 }
34696
34697
34698 static PyObject * DragImage_swigregister(PyObject *, PyObject *args) {
34699     PyObject *obj;
34700     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34701     SWIG_TypeClientData(SWIGTYPE_p_wxGenericDragImage, obj);
34702     Py_INCREF(obj);
34703     return Py_BuildValue((char *)"");
34704 }
34705 static PyMethodDef SwigMethods[] = {
34706          { (char *)"new_Button", (PyCFunction) _wrap_new_Button, METH_VARARGS | METH_KEYWORDS, NULL},
34707          { (char *)"new_PreButton", (PyCFunction) _wrap_new_PreButton, METH_VARARGS | METH_KEYWORDS, NULL},
34708          { (char *)"Button_Create", (PyCFunction) _wrap_Button_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34709          { (char *)"Button_SetDefault", (PyCFunction) _wrap_Button_SetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
34710          { (char *)"Button_GetDefaultSize", (PyCFunction) _wrap_Button_GetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
34711          { (char *)"Button_GetClassDefaultAttributes", (PyCFunction) _wrap_Button_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34712          { (char *)"Button_swigregister", Button_swigregister, METH_VARARGS, NULL},
34713          { (char *)"new_BitmapButton", (PyCFunction) _wrap_new_BitmapButton, METH_VARARGS | METH_KEYWORDS, NULL},
34714          { (char *)"new_PreBitmapButton", (PyCFunction) _wrap_new_PreBitmapButton, METH_VARARGS | METH_KEYWORDS, NULL},
34715          { (char *)"BitmapButton_Create", (PyCFunction) _wrap_BitmapButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34716          { (char *)"BitmapButton_GetBitmapLabel", (PyCFunction) _wrap_BitmapButton_GetBitmapLabel, METH_VARARGS | METH_KEYWORDS, NULL},
34717          { (char *)"BitmapButton_GetBitmapDisabled", (PyCFunction) _wrap_BitmapButton_GetBitmapDisabled, METH_VARARGS | METH_KEYWORDS, NULL},
34718          { (char *)"BitmapButton_GetBitmapFocus", (PyCFunction) _wrap_BitmapButton_GetBitmapFocus, METH_VARARGS | METH_KEYWORDS, NULL},
34719          { (char *)"BitmapButton_GetBitmapSelected", (PyCFunction) _wrap_BitmapButton_GetBitmapSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34720          { (char *)"BitmapButton_SetBitmapDisabled", (PyCFunction) _wrap_BitmapButton_SetBitmapDisabled, METH_VARARGS | METH_KEYWORDS, NULL},
34721          { (char *)"BitmapButton_SetBitmapFocus", (PyCFunction) _wrap_BitmapButton_SetBitmapFocus, METH_VARARGS | METH_KEYWORDS, NULL},
34722          { (char *)"BitmapButton_SetBitmapSelected", (PyCFunction) _wrap_BitmapButton_SetBitmapSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34723          { (char *)"BitmapButton_SetBitmapLabel", (PyCFunction) _wrap_BitmapButton_SetBitmapLabel, METH_VARARGS | METH_KEYWORDS, NULL},
34724          { (char *)"BitmapButton_SetMargins", (PyCFunction) _wrap_BitmapButton_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
34725          { (char *)"BitmapButton_GetMarginX", (PyCFunction) _wrap_BitmapButton_GetMarginX, METH_VARARGS | METH_KEYWORDS, NULL},
34726          { (char *)"BitmapButton_GetMarginY", (PyCFunction) _wrap_BitmapButton_GetMarginY, METH_VARARGS | METH_KEYWORDS, NULL},
34727          { (char *)"BitmapButton_swigregister", BitmapButton_swigregister, METH_VARARGS, NULL},
34728          { (char *)"new_CheckBox", (PyCFunction) _wrap_new_CheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
34729          { (char *)"new_PreCheckBox", (PyCFunction) _wrap_new_PreCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
34730          { (char *)"CheckBox_Create", (PyCFunction) _wrap_CheckBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34731          { (char *)"CheckBox_GetValue", (PyCFunction) _wrap_CheckBox_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34732          { (char *)"CheckBox_IsChecked", (PyCFunction) _wrap_CheckBox_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
34733          { (char *)"CheckBox_SetValue", (PyCFunction) _wrap_CheckBox_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34734          { (char *)"CheckBox_Get3StateValue", (PyCFunction) _wrap_CheckBox_Get3StateValue, METH_VARARGS | METH_KEYWORDS, NULL},
34735          { (char *)"CheckBox_Set3StateValue", (PyCFunction) _wrap_CheckBox_Set3StateValue, METH_VARARGS | METH_KEYWORDS, NULL},
34736          { (char *)"CheckBox_Is3State", (PyCFunction) _wrap_CheckBox_Is3State, METH_VARARGS | METH_KEYWORDS, NULL},
34737          { (char *)"CheckBox_Is3rdStateAllowedForUser", (PyCFunction) _wrap_CheckBox_Is3rdStateAllowedForUser, METH_VARARGS | METH_KEYWORDS, NULL},
34738          { (char *)"CheckBox_GetClassDefaultAttributes", (PyCFunction) _wrap_CheckBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34739          { (char *)"CheckBox_swigregister", CheckBox_swigregister, METH_VARARGS, NULL},
34740          { (char *)"new_Choice", (PyCFunction) _wrap_new_Choice, METH_VARARGS | METH_KEYWORDS, NULL},
34741          { (char *)"new_PreChoice", (PyCFunction) _wrap_new_PreChoice, METH_VARARGS | METH_KEYWORDS, NULL},
34742          { (char *)"Choice_Create", (PyCFunction) _wrap_Choice_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34743          { (char *)"Choice_SetSelection", (PyCFunction) _wrap_Choice_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34744          { (char *)"Choice_SetStringSelection", (PyCFunction) _wrap_Choice_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34745          { (char *)"Choice_SetString", (PyCFunction) _wrap_Choice_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
34746          { (char *)"Choice_GetClassDefaultAttributes", (PyCFunction) _wrap_Choice_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34747          { (char *)"Choice_swigregister", Choice_swigregister, METH_VARARGS, NULL},
34748          { (char *)"new_ComboBox", (PyCFunction) _wrap_new_ComboBox, METH_VARARGS | METH_KEYWORDS, NULL},
34749          { (char *)"new_PreComboBox", (PyCFunction) _wrap_new_PreComboBox, METH_VARARGS | METH_KEYWORDS, NULL},
34750          { (char *)"ComboBox_Create", (PyCFunction) _wrap_ComboBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34751          { (char *)"ComboBox_GetValue", (PyCFunction) _wrap_ComboBox_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34752          { (char *)"ComboBox_SetValue", (PyCFunction) _wrap_ComboBox_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34753          { (char *)"ComboBox_Copy", (PyCFunction) _wrap_ComboBox_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
34754          { (char *)"ComboBox_Cut", (PyCFunction) _wrap_ComboBox_Cut, METH_VARARGS | METH_KEYWORDS, NULL},
34755          { (char *)"ComboBox_Paste", (PyCFunction) _wrap_ComboBox_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
34756          { (char *)"ComboBox_SetInsertionPoint", (PyCFunction) _wrap_ComboBox_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34757          { (char *)"ComboBox_GetInsertionPoint", (PyCFunction) _wrap_ComboBox_GetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34758          { (char *)"ComboBox_GetLastPosition", (PyCFunction) _wrap_ComboBox_GetLastPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34759          { (char *)"ComboBox_Replace", (PyCFunction) _wrap_ComboBox_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
34760          { (char *)"ComboBox_SetSelection", (PyCFunction) _wrap_ComboBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34761          { (char *)"ComboBox_SetMark", (PyCFunction) _wrap_ComboBox_SetMark, METH_VARARGS | METH_KEYWORDS, NULL},
34762          { (char *)"ComboBox_GetMark", (PyCFunction) _wrap_ComboBox_GetMark, METH_VARARGS | METH_KEYWORDS, NULL},
34763          { (char *)"ComboBox_SetStringSelection", (PyCFunction) _wrap_ComboBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34764          { (char *)"ComboBox_SetString", (PyCFunction) _wrap_ComboBox_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
34765          { (char *)"ComboBox_SetEditable", (PyCFunction) _wrap_ComboBox_SetEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34766          { (char *)"ComboBox_SetInsertionPointEnd", (PyCFunction) _wrap_ComboBox_SetInsertionPointEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34767          { (char *)"ComboBox_Remove", (PyCFunction) _wrap_ComboBox_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
34768          { (char *)"ComboBox_IsEditable", (PyCFunction) _wrap_ComboBox_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34769          { (char *)"ComboBox_Undo", (PyCFunction) _wrap_ComboBox_Undo, METH_VARARGS | METH_KEYWORDS, NULL},
34770          { (char *)"ComboBox_Redo", (PyCFunction) _wrap_ComboBox_Redo, METH_VARARGS | METH_KEYWORDS, NULL},
34771          { (char *)"ComboBox_SelectAll", (PyCFunction) _wrap_ComboBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34772          { (char *)"ComboBox_CanCopy", (PyCFunction) _wrap_ComboBox_CanCopy, METH_VARARGS | METH_KEYWORDS, NULL},
34773          { (char *)"ComboBox_CanCut", (PyCFunction) _wrap_ComboBox_CanCut, METH_VARARGS | METH_KEYWORDS, NULL},
34774          { (char *)"ComboBox_CanPaste", (PyCFunction) _wrap_ComboBox_CanPaste, METH_VARARGS | METH_KEYWORDS, NULL},
34775          { (char *)"ComboBox_CanUndo", (PyCFunction) _wrap_ComboBox_CanUndo, METH_VARARGS | METH_KEYWORDS, NULL},
34776          { (char *)"ComboBox_CanRedo", (PyCFunction) _wrap_ComboBox_CanRedo, METH_VARARGS | METH_KEYWORDS, NULL},
34777          { (char *)"ComboBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ComboBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34778          { (char *)"ComboBox_swigregister", ComboBox_swigregister, METH_VARARGS, NULL},
34779          { (char *)"new_Gauge", (PyCFunction) _wrap_new_Gauge, METH_VARARGS | METH_KEYWORDS, NULL},
34780          { (char *)"new_PreGauge", (PyCFunction) _wrap_new_PreGauge, METH_VARARGS | METH_KEYWORDS, NULL},
34781          { (char *)"Gauge_Create", (PyCFunction) _wrap_Gauge_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34782          { (char *)"Gauge_SetRange", (PyCFunction) _wrap_Gauge_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34783          { (char *)"Gauge_GetRange", (PyCFunction) _wrap_Gauge_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34784          { (char *)"Gauge_SetValue", (PyCFunction) _wrap_Gauge_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34785          { (char *)"Gauge_GetValue", (PyCFunction) _wrap_Gauge_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34786          { (char *)"Gauge_IsVertical", (PyCFunction) _wrap_Gauge_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34787          { (char *)"Gauge_SetShadowWidth", (PyCFunction) _wrap_Gauge_SetShadowWidth, METH_VARARGS | METH_KEYWORDS, NULL},
34788          { (char *)"Gauge_GetShadowWidth", (PyCFunction) _wrap_Gauge_GetShadowWidth, METH_VARARGS | METH_KEYWORDS, NULL},
34789          { (char *)"Gauge_SetBezelFace", (PyCFunction) _wrap_Gauge_SetBezelFace, METH_VARARGS | METH_KEYWORDS, NULL},
34790          { (char *)"Gauge_GetBezelFace", (PyCFunction) _wrap_Gauge_GetBezelFace, METH_VARARGS | METH_KEYWORDS, NULL},
34791          { (char *)"Gauge_GetClassDefaultAttributes", (PyCFunction) _wrap_Gauge_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34792          { (char *)"Gauge_swigregister", Gauge_swigregister, METH_VARARGS, NULL},
34793          { (char *)"new_StaticBox", (PyCFunction) _wrap_new_StaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
34794          { (char *)"new_PreStaticBox", (PyCFunction) _wrap_new_PreStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
34795          { (char *)"StaticBox_Create", (PyCFunction) _wrap_StaticBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34796          { (char *)"StaticBox_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34797          { (char *)"StaticBox_swigregister", StaticBox_swigregister, METH_VARARGS, NULL},
34798          { (char *)"new_StaticLine", (PyCFunction) _wrap_new_StaticLine, METH_VARARGS | METH_KEYWORDS, NULL},
34799          { (char *)"new_PreStaticLine", (PyCFunction) _wrap_new_PreStaticLine, METH_VARARGS | METH_KEYWORDS, NULL},
34800          { (char *)"StaticLine_Create", (PyCFunction) _wrap_StaticLine_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34801          { (char *)"StaticLine_IsVertical", (PyCFunction) _wrap_StaticLine_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34802          { (char *)"StaticLine_GetDefaultSize", (PyCFunction) _wrap_StaticLine_GetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
34803          { (char *)"StaticLine_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticLine_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34804          { (char *)"StaticLine_swigregister", StaticLine_swigregister, METH_VARARGS, NULL},
34805          { (char *)"new_StaticText", (PyCFunction) _wrap_new_StaticText, METH_VARARGS | METH_KEYWORDS, NULL},
34806          { (char *)"new_PreStaticText", (PyCFunction) _wrap_new_PreStaticText, METH_VARARGS | METH_KEYWORDS, NULL},
34807          { (char *)"StaticText_Create", (PyCFunction) _wrap_StaticText_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34808          { (char *)"StaticText_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticText_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34809          { (char *)"StaticText_swigregister", StaticText_swigregister, METH_VARARGS, NULL},
34810          { (char *)"new_StaticBitmap", (PyCFunction) _wrap_new_StaticBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34811          { (char *)"new_PreStaticBitmap", (PyCFunction) _wrap_new_PreStaticBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34812          { (char *)"StaticBitmap_Create", (PyCFunction) _wrap_StaticBitmap_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34813          { (char *)"StaticBitmap_GetBitmap", (PyCFunction) _wrap_StaticBitmap_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34814          { (char *)"StaticBitmap_SetBitmap", (PyCFunction) _wrap_StaticBitmap_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34815          { (char *)"StaticBitmap_SetIcon", (PyCFunction) _wrap_StaticBitmap_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
34816          { (char *)"StaticBitmap_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBitmap_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34817          { (char *)"StaticBitmap_swigregister", StaticBitmap_swigregister, METH_VARARGS, NULL},
34818          { (char *)"new_ListBox", (PyCFunction) _wrap_new_ListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34819          { (char *)"new_PreListBox", (PyCFunction) _wrap_new_PreListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34820          { (char *)"ListBox_Create", (PyCFunction) _wrap_ListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34821          { (char *)"ListBox_Insert", (PyCFunction) _wrap_ListBox_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
34822          { (char *)"ListBox_InsertItems", (PyCFunction) _wrap_ListBox_InsertItems, METH_VARARGS | METH_KEYWORDS, NULL},
34823          { (char *)"ListBox_Set", (PyCFunction) _wrap_ListBox_Set, METH_VARARGS | METH_KEYWORDS, NULL},
34824          { (char *)"ListBox_IsSelected", (PyCFunction) _wrap_ListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34825          { (char *)"ListBox_SetSelection", (PyCFunction) _wrap_ListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34826          { (char *)"ListBox_Select", (PyCFunction) _wrap_ListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
34827          { (char *)"ListBox_Deselect", (PyCFunction) _wrap_ListBox_Deselect, METH_VARARGS | METH_KEYWORDS, NULL},
34828          { (char *)"ListBox_DeselectAll", (PyCFunction) _wrap_ListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34829          { (char *)"ListBox_SetStringSelection", (PyCFunction) _wrap_ListBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34830          { (char *)"ListBox_GetSelections", (PyCFunction) _wrap_ListBox_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
34831          { (char *)"ListBox_SetFirstItem", (PyCFunction) _wrap_ListBox_SetFirstItem, METH_VARARGS | METH_KEYWORDS, NULL},
34832          { (char *)"ListBox_SetFirstItemStr", (PyCFunction) _wrap_ListBox_SetFirstItemStr, METH_VARARGS | METH_KEYWORDS, NULL},
34833          { (char *)"ListBox_EnsureVisible", (PyCFunction) _wrap_ListBox_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
34834          { (char *)"ListBox_AppendAndEnsureVisible", (PyCFunction) _wrap_ListBox_AppendAndEnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
34835          { (char *)"ListBox_IsSorted", (PyCFunction) _wrap_ListBox_IsSorted, METH_VARARGS | METH_KEYWORDS, NULL},
34836          { (char *)"ListBox_SetItemForegroundColour", (PyCFunction) _wrap_ListBox_SetItemForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34837          { (char *)"ListBox_SetItemBackgroundColour", (PyCFunction) _wrap_ListBox_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34838          { (char *)"ListBox_SetItemFont", (PyCFunction) _wrap_ListBox_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
34839          { (char *)"ListBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ListBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34840          { (char *)"ListBox_swigregister", ListBox_swigregister, METH_VARARGS, NULL},
34841          { (char *)"new_CheckListBox", (PyCFunction) _wrap_new_CheckListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34842          { (char *)"new_PreCheckListBox", (PyCFunction) _wrap_new_PreCheckListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34843          { (char *)"CheckListBox_Create", (PyCFunction) _wrap_CheckListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34844          { (char *)"CheckListBox_IsChecked", (PyCFunction) _wrap_CheckListBox_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
34845          { (char *)"CheckListBox_Check", (PyCFunction) _wrap_CheckListBox_Check, METH_VARARGS | METH_KEYWORDS, NULL},
34846          { (char *)"CheckListBox_GetItemHeight", (PyCFunction) _wrap_CheckListBox_GetItemHeight, METH_VARARGS | METH_KEYWORDS, NULL},
34847          { (char *)"CheckListBox_HitTest", (PyCFunction) _wrap_CheckListBox_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
34848          { (char *)"CheckListBox_HitTestXY", (PyCFunction) _wrap_CheckListBox_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
34849          { (char *)"CheckListBox_swigregister", CheckListBox_swigregister, METH_VARARGS, NULL},
34850          { (char *)"new_TextAttr", (PyCFunction) _wrap_new_TextAttr, METH_VARARGS | METH_KEYWORDS, NULL},
34851          { (char *)"delete_TextAttr", (PyCFunction) _wrap_delete_TextAttr, METH_VARARGS | METH_KEYWORDS, NULL},
34852          { (char *)"TextAttr_Init", (PyCFunction) _wrap_TextAttr_Init, METH_VARARGS | METH_KEYWORDS, NULL},
34853          { (char *)"TextAttr_SetTextColour", (PyCFunction) _wrap_TextAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34854          { (char *)"TextAttr_SetBackgroundColour", (PyCFunction) _wrap_TextAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34855          { (char *)"TextAttr_SetFont", (PyCFunction) _wrap_TextAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
34856          { (char *)"TextAttr_SetAlignment", (PyCFunction) _wrap_TextAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34857          { (char *)"TextAttr_SetTabs", (PyCFunction) _wrap_TextAttr_SetTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34858          { (char *)"TextAttr_SetLeftIndent", (PyCFunction) _wrap_TextAttr_SetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34859          { (char *)"TextAttr_SetRightIndent", (PyCFunction) _wrap_TextAttr_SetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34860          { (char *)"TextAttr_SetFlags", (PyCFunction) _wrap_TextAttr_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
34861          { (char *)"TextAttr_HasTextColour", (PyCFunction) _wrap_TextAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34862          { (char *)"TextAttr_HasBackgroundColour", (PyCFunction) _wrap_TextAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34863          { (char *)"TextAttr_HasFont", (PyCFunction) _wrap_TextAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
34864          { (char *)"TextAttr_HasAlignment", (PyCFunction) _wrap_TextAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34865          { (char *)"TextAttr_HasTabs", (PyCFunction) _wrap_TextAttr_HasTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34866          { (char *)"TextAttr_HasLeftIndent", (PyCFunction) _wrap_TextAttr_HasLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34867          { (char *)"TextAttr_HasRightIndent", (PyCFunction) _wrap_TextAttr_HasRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34868          { (char *)"TextAttr_HasFlag", (PyCFunction) _wrap_TextAttr_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
34869          { (char *)"TextAttr_GetTextColour", (PyCFunction) _wrap_TextAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34870          { (char *)"TextAttr_GetBackgroundColour", (PyCFunction) _wrap_TextAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34871          { (char *)"TextAttr_GetFont", (PyCFunction) _wrap_TextAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
34872          { (char *)"TextAttr_GetAlignment", (PyCFunction) _wrap_TextAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34873          { (char *)"TextAttr_GetTabs", (PyCFunction) _wrap_TextAttr_GetTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34874          { (char *)"TextAttr_GetLeftIndent", (PyCFunction) _wrap_TextAttr_GetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34875          { (char *)"TextAttr_GetLeftSubIndent", (PyCFunction) _wrap_TextAttr_GetLeftSubIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34876          { (char *)"TextAttr_GetRightIndent", (PyCFunction) _wrap_TextAttr_GetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34877          { (char *)"TextAttr_GetFlags", (PyCFunction) _wrap_TextAttr_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
34878          { (char *)"TextAttr_IsDefault", (PyCFunction) _wrap_TextAttr_IsDefault, METH_VARARGS | METH_KEYWORDS, NULL},
34879          { (char *)"TextAttr_Combine", (PyCFunction) _wrap_TextAttr_Combine, METH_VARARGS | METH_KEYWORDS, NULL},
34880          { (char *)"TextAttr_swigregister", TextAttr_swigregister, METH_VARARGS, NULL},
34881          { (char *)"new_TextCtrl", (PyCFunction) _wrap_new_TextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34882          { (char *)"new_PreTextCtrl", (PyCFunction) _wrap_new_PreTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34883          { (char *)"TextCtrl_Create", (PyCFunction) _wrap_TextCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34884          { (char *)"TextCtrl_GetValue", (PyCFunction) _wrap_TextCtrl_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34885          { (char *)"TextCtrl_SetValue", (PyCFunction) _wrap_TextCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34886          { (char *)"TextCtrl_GetRange", (PyCFunction) _wrap_TextCtrl_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34887          { (char *)"TextCtrl_GetLineLength", (PyCFunction) _wrap_TextCtrl_GetLineLength, METH_VARARGS | METH_KEYWORDS, NULL},
34888          { (char *)"TextCtrl_GetLineText", (PyCFunction) _wrap_TextCtrl_GetLineText, METH_VARARGS | METH_KEYWORDS, NULL},
34889          { (char *)"TextCtrl_GetNumberOfLines", (PyCFunction) _wrap_TextCtrl_GetNumberOfLines, METH_VARARGS | METH_KEYWORDS, NULL},
34890          { (char *)"TextCtrl_IsModified", (PyCFunction) _wrap_TextCtrl_IsModified, METH_VARARGS | METH_KEYWORDS, NULL},
34891          { (char *)"TextCtrl_IsEditable", (PyCFunction) _wrap_TextCtrl_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34892          { (char *)"TextCtrl_IsSingleLine", (PyCFunction) _wrap_TextCtrl_IsSingleLine, METH_VARARGS | METH_KEYWORDS, NULL},
34893          { (char *)"TextCtrl_IsMultiLine", (PyCFunction) _wrap_TextCtrl_IsMultiLine, METH_VARARGS | METH_KEYWORDS, NULL},
34894          { (char *)"TextCtrl_GetSelection", (PyCFunction) _wrap_TextCtrl_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34895          { (char *)"TextCtrl_GetStringSelection", (PyCFunction) _wrap_TextCtrl_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34896          { (char *)"TextCtrl_Clear", (PyCFunction) _wrap_TextCtrl_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
34897          { (char *)"TextCtrl_Replace", (PyCFunction) _wrap_TextCtrl_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
34898          { (char *)"TextCtrl_Remove", (PyCFunction) _wrap_TextCtrl_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
34899          { (char *)"TextCtrl_LoadFile", (PyCFunction) _wrap_TextCtrl_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
34900          { (char *)"TextCtrl_SaveFile", (PyCFunction) _wrap_TextCtrl_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
34901          { (char *)"TextCtrl_MarkDirty", (PyCFunction) _wrap_TextCtrl_MarkDirty, METH_VARARGS | METH_KEYWORDS, NULL},
34902          { (char *)"TextCtrl_DiscardEdits", (PyCFunction) _wrap_TextCtrl_DiscardEdits, METH_VARARGS | METH_KEYWORDS, NULL},
34903          { (char *)"TextCtrl_SetMaxLength", (PyCFunction) _wrap_TextCtrl_SetMaxLength, METH_VARARGS | METH_KEYWORDS, NULL},
34904          { (char *)"TextCtrl_WriteText", (PyCFunction) _wrap_TextCtrl_WriteText, METH_VARARGS | METH_KEYWORDS, NULL},
34905          { (char *)"TextCtrl_AppendText", (PyCFunction) _wrap_TextCtrl_AppendText, METH_VARARGS | METH_KEYWORDS, NULL},
34906          { (char *)"TextCtrl_EmulateKeyPress", (PyCFunction) _wrap_TextCtrl_EmulateKeyPress, METH_VARARGS | METH_KEYWORDS, NULL},
34907          { (char *)"TextCtrl_SetStyle", (PyCFunction) _wrap_TextCtrl_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34908          { (char *)"TextCtrl_GetStyle", (PyCFunction) _wrap_TextCtrl_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34909          { (char *)"TextCtrl_SetDefaultStyle", (PyCFunction) _wrap_TextCtrl_SetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34910          { (char *)"TextCtrl_GetDefaultStyle", (PyCFunction) _wrap_TextCtrl_GetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34911          { (char *)"TextCtrl_XYToPosition", (PyCFunction) _wrap_TextCtrl_XYToPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34912          { (char *)"TextCtrl_PositionToXY", (PyCFunction) _wrap_TextCtrl_PositionToXY, METH_VARARGS | METH_KEYWORDS, NULL},
34913          { (char *)"TextCtrl_ShowPosition", (PyCFunction) _wrap_TextCtrl_ShowPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34914          { (char *)"TextCtrl_HitTest", (PyCFunction) _wrap_TextCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
34915          { (char *)"TextCtrl_HitTestPos", (PyCFunction) _wrap_TextCtrl_HitTestPos, METH_VARARGS | METH_KEYWORDS, NULL},
34916          { (char *)"TextCtrl_Copy", (PyCFunction) _wrap_TextCtrl_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
34917          { (char *)"TextCtrl_Cut", (PyCFunction) _wrap_TextCtrl_Cut, METH_VARARGS | METH_KEYWORDS, NULL},
34918          { (char *)"TextCtrl_Paste", (PyCFunction) _wrap_TextCtrl_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
34919          { (char *)"TextCtrl_CanCopy", (PyCFunction) _wrap_TextCtrl_CanCopy, METH_VARARGS | METH_KEYWORDS, NULL},
34920          { (char *)"TextCtrl_CanCut", (PyCFunction) _wrap_TextCtrl_CanCut, METH_VARARGS | METH_KEYWORDS, NULL},
34921          { (char *)"TextCtrl_CanPaste", (PyCFunction) _wrap_TextCtrl_CanPaste, METH_VARARGS | METH_KEYWORDS, NULL},
34922          { (char *)"TextCtrl_Undo", (PyCFunction) _wrap_TextCtrl_Undo, METH_VARARGS | METH_KEYWORDS, NULL},
34923          { (char *)"TextCtrl_Redo", (PyCFunction) _wrap_TextCtrl_Redo, METH_VARARGS | METH_KEYWORDS, NULL},
34924          { (char *)"TextCtrl_CanUndo", (PyCFunction) _wrap_TextCtrl_CanUndo, METH_VARARGS | METH_KEYWORDS, NULL},
34925          { (char *)"TextCtrl_CanRedo", (PyCFunction) _wrap_TextCtrl_CanRedo, METH_VARARGS | METH_KEYWORDS, NULL},
34926          { (char *)"TextCtrl_SetInsertionPoint", (PyCFunction) _wrap_TextCtrl_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34927          { (char *)"TextCtrl_SetInsertionPointEnd", (PyCFunction) _wrap_TextCtrl_SetInsertionPointEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34928          { (char *)"TextCtrl_GetInsertionPoint", (PyCFunction) _wrap_TextCtrl_GetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34929          { (char *)"TextCtrl_GetLastPosition", (PyCFunction) _wrap_TextCtrl_GetLastPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34930          { (char *)"TextCtrl_SetSelection", (PyCFunction) _wrap_TextCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34931          { (char *)"TextCtrl_SelectAll", (PyCFunction) _wrap_TextCtrl_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34932          { (char *)"TextCtrl_SetEditable", (PyCFunction) _wrap_TextCtrl_SetEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34933          { (char *)"TextCtrl_ShowNativeCaret", (PyCFunction) _wrap_TextCtrl_ShowNativeCaret, METH_VARARGS | METH_KEYWORDS, NULL},
34934          { (char *)"TextCtrl_HideNativeCaret", (PyCFunction) _wrap_TextCtrl_HideNativeCaret, METH_VARARGS | METH_KEYWORDS, NULL},
34935          { (char *)"TextCtrl_write", (PyCFunction) _wrap_TextCtrl_write, METH_VARARGS | METH_KEYWORDS, NULL},
34936          { (char *)"TextCtrl_GetString", (PyCFunction) _wrap_TextCtrl_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
34937          { (char *)"TextCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TextCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34938          { (char *)"TextCtrl_swigregister", TextCtrl_swigregister, METH_VARARGS, NULL},
34939          { (char *)"new_TextUrlEvent", (PyCFunction) _wrap_new_TextUrlEvent, METH_VARARGS | METH_KEYWORDS, NULL},
34940          { (char *)"TextUrlEvent_GetMouseEvent", (PyCFunction) _wrap_TextUrlEvent_GetMouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
34941          { (char *)"TextUrlEvent_GetURLStart", (PyCFunction) _wrap_TextUrlEvent_GetURLStart, METH_VARARGS | METH_KEYWORDS, NULL},
34942          { (char *)"TextUrlEvent_GetURLEnd", (PyCFunction) _wrap_TextUrlEvent_GetURLEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34943          { (char *)"TextUrlEvent_swigregister", TextUrlEvent_swigregister, METH_VARARGS, NULL},
34944          { (char *)"new_ScrollBar", (PyCFunction) _wrap_new_ScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},
34945          { (char *)"new_PreScrollBar", (PyCFunction) _wrap_new_PreScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},
34946          { (char *)"ScrollBar_Create", (PyCFunction) _wrap_ScrollBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34947          { (char *)"ScrollBar_GetThumbPosition", (PyCFunction) _wrap_ScrollBar_GetThumbPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34948          { (char *)"ScrollBar_GetThumbSize", (PyCFunction) _wrap_ScrollBar_GetThumbSize, METH_VARARGS | METH_KEYWORDS, NULL},
34949          { (char *)"ScrollBar_GetPageSize", (PyCFunction) _wrap_ScrollBar_GetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
34950          { (char *)"ScrollBar_GetRange", (PyCFunction) _wrap_ScrollBar_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34951          { (char *)"ScrollBar_IsVertical", (PyCFunction) _wrap_ScrollBar_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34952          { (char *)"ScrollBar_SetThumbPosition", (PyCFunction) _wrap_ScrollBar_SetThumbPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34953          { (char *)"ScrollBar_SetScrollbar", (PyCFunction) _wrap_ScrollBar_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
34954          { (char *)"ScrollBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrollBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34955          { (char *)"ScrollBar_swigregister", ScrollBar_swigregister, METH_VARARGS, NULL},
34956          { (char *)"new_SpinButton", (PyCFunction) _wrap_new_SpinButton, METH_VARARGS | METH_KEYWORDS, NULL},
34957          { (char *)"new_PreSpinButton", (PyCFunction) _wrap_new_PreSpinButton, METH_VARARGS | METH_KEYWORDS, NULL},
34958          { (char *)"SpinButton_Create", (PyCFunction) _wrap_SpinButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34959          { (char *)"SpinButton_GetValue", (PyCFunction) _wrap_SpinButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34960          { (char *)"SpinButton_GetMin", (PyCFunction) _wrap_SpinButton_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
34961          { (char *)"SpinButton_GetMax", (PyCFunction) _wrap_SpinButton_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
34962          { (char *)"SpinButton_SetValue", (PyCFunction) _wrap_SpinButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34963          { (char *)"SpinButton_SetMin", (PyCFunction) _wrap_SpinButton_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
34964          { (char *)"SpinButton_SetMax", (PyCFunction) _wrap_SpinButton_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
34965          { (char *)"SpinButton_SetRange", (PyCFunction) _wrap_SpinButton_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34966          { (char *)"SpinButton_IsVertical", (PyCFunction) _wrap_SpinButton_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34967          { (char *)"SpinButton_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34968          { (char *)"SpinButton_swigregister", SpinButton_swigregister, METH_VARARGS, NULL},
34969          { (char *)"new_SpinCtrl", (PyCFunction) _wrap_new_SpinCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34970          { (char *)"new_PreSpinCtrl", (PyCFunction) _wrap_new_PreSpinCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34971          { (char *)"SpinCtrl_Create", (PyCFunction) _wrap_SpinCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34972          { (char *)"SpinCtrl_GetValue", (PyCFunction) _wrap_SpinCtrl_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34973          { (char *)"SpinCtrl_SetValue", (PyCFunction) _wrap_SpinCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34974          { (char *)"SpinCtrl_SetValueString", (PyCFunction) _wrap_SpinCtrl_SetValueString, METH_VARARGS | METH_KEYWORDS, NULL},
34975          { (char *)"SpinCtrl_SetRange", (PyCFunction) _wrap_SpinCtrl_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34976          { (char *)"SpinCtrl_GetMin", (PyCFunction) _wrap_SpinCtrl_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
34977          { (char *)"SpinCtrl_GetMax", (PyCFunction) _wrap_SpinCtrl_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
34978          { (char *)"SpinCtrl_SetSelection", (PyCFunction) _wrap_SpinCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34979          { (char *)"SpinCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34980          { (char *)"SpinCtrl_swigregister", SpinCtrl_swigregister, METH_VARARGS, NULL},
34981          { (char *)"new_SpinEvent", (PyCFunction) _wrap_new_SpinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
34982          { (char *)"SpinEvent_GetPosition", (PyCFunction) _wrap_SpinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34983          { (char *)"SpinEvent_SetPosition", (PyCFunction) _wrap_SpinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34984          { (char *)"SpinEvent_swigregister", SpinEvent_swigregister, METH_VARARGS, NULL},
34985          { (char *)"new_RadioBox", (PyCFunction) _wrap_new_RadioBox, METH_VARARGS | METH_KEYWORDS, NULL},
34986          { (char *)"new_PreRadioBox", (PyCFunction) _wrap_new_PreRadioBox, METH_VARARGS | METH_KEYWORDS, NULL},
34987          { (char *)"RadioBox_Create", (PyCFunction) _wrap_RadioBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34988          { (char *)"RadioBox_SetSelection", (PyCFunction) _wrap_RadioBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34989          { (char *)"RadioBox_GetSelection", (PyCFunction) _wrap_RadioBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34990          { (char *)"RadioBox_GetStringSelection", (PyCFunction) _wrap_RadioBox_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34991          { (char *)"RadioBox_SetStringSelection", (PyCFunction) _wrap_RadioBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34992          { (char *)"RadioBox_GetCount", (PyCFunction) _wrap_RadioBox_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
34993          { (char *)"RadioBox_FindString", (PyCFunction) _wrap_RadioBox_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
34994          { (char *)"RadioBox_GetString", (PyCFunction) _wrap_RadioBox_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
34995          { (char *)"RadioBox_SetString", (PyCFunction) _wrap_RadioBox_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
34996          { (char *)"RadioBox_EnableItem", (PyCFunction) _wrap_RadioBox_EnableItem, METH_VARARGS | METH_KEYWORDS, NULL},
34997          { (char *)"RadioBox_ShowItem", (PyCFunction) _wrap_RadioBox_ShowItem, METH_VARARGS | METH_KEYWORDS, NULL},
34998          { (char *)"RadioBox_GetColumnCount", (PyCFunction) _wrap_RadioBox_GetColumnCount, METH_VARARGS | METH_KEYWORDS, NULL},
34999          { (char *)"RadioBox_GetRowCount", (PyCFunction) _wrap_RadioBox_GetRowCount, METH_VARARGS | METH_KEYWORDS, NULL},
35000          { (char *)"RadioBox_GetNextItem", (PyCFunction) _wrap_RadioBox_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
35001          { (char *)"RadioBox_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35002          { (char *)"RadioBox_swigregister", RadioBox_swigregister, METH_VARARGS, NULL},
35003          { (char *)"new_RadioButton", (PyCFunction) _wrap_new_RadioButton, METH_VARARGS | METH_KEYWORDS, NULL},
35004          { (char *)"new_PreRadioButton", (PyCFunction) _wrap_new_PreRadioButton, METH_VARARGS | METH_KEYWORDS, NULL},
35005          { (char *)"RadioButton_Create", (PyCFunction) _wrap_RadioButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35006          { (char *)"RadioButton_GetValue", (PyCFunction) _wrap_RadioButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35007          { (char *)"RadioButton_SetValue", (PyCFunction) _wrap_RadioButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35008          { (char *)"RadioButton_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35009          { (char *)"RadioButton_swigregister", RadioButton_swigregister, METH_VARARGS, NULL},
35010          { (char *)"new_Slider", (PyCFunction) _wrap_new_Slider, METH_VARARGS | METH_KEYWORDS, NULL},
35011          { (char *)"new_PreSlider", (PyCFunction) _wrap_new_PreSlider, METH_VARARGS | METH_KEYWORDS, NULL},
35012          { (char *)"Slider_Create", (PyCFunction) _wrap_Slider_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35013          { (char *)"Slider_GetValue", (PyCFunction) _wrap_Slider_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35014          { (char *)"Slider_SetValue", (PyCFunction) _wrap_Slider_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35015          { (char *)"Slider_SetRange", (PyCFunction) _wrap_Slider_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
35016          { (char *)"Slider_GetMin", (PyCFunction) _wrap_Slider_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
35017          { (char *)"Slider_GetMax", (PyCFunction) _wrap_Slider_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
35018          { (char *)"Slider_SetMin", (PyCFunction) _wrap_Slider_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
35019          { (char *)"Slider_SetMax", (PyCFunction) _wrap_Slider_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
35020          { (char *)"Slider_SetLineSize", (PyCFunction) _wrap_Slider_SetLineSize, METH_VARARGS | METH_KEYWORDS, NULL},
35021          { (char *)"Slider_SetPageSize", (PyCFunction) _wrap_Slider_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35022          { (char *)"Slider_GetLineSize", (PyCFunction) _wrap_Slider_GetLineSize, METH_VARARGS | METH_KEYWORDS, NULL},
35023          { (char *)"Slider_GetPageSize", (PyCFunction) _wrap_Slider_GetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35024          { (char *)"Slider_SetThumbLength", (PyCFunction) _wrap_Slider_SetThumbLength, METH_VARARGS | METH_KEYWORDS, NULL},
35025          { (char *)"Slider_GetThumbLength", (PyCFunction) _wrap_Slider_GetThumbLength, METH_VARARGS | METH_KEYWORDS, NULL},
35026          { (char *)"Slider_SetTickFreq", (PyCFunction) _wrap_Slider_SetTickFreq, METH_VARARGS | METH_KEYWORDS, NULL},
35027          { (char *)"Slider_GetTickFreq", (PyCFunction) _wrap_Slider_GetTickFreq, METH_VARARGS | METH_KEYWORDS, NULL},
35028          { (char *)"Slider_ClearTicks", (PyCFunction) _wrap_Slider_ClearTicks, METH_VARARGS | METH_KEYWORDS, NULL},
35029          { (char *)"Slider_SetTick", (PyCFunction) _wrap_Slider_SetTick, METH_VARARGS | METH_KEYWORDS, NULL},
35030          { (char *)"Slider_ClearSel", (PyCFunction) _wrap_Slider_ClearSel, METH_VARARGS | METH_KEYWORDS, NULL},
35031          { (char *)"Slider_GetSelEnd", (PyCFunction) _wrap_Slider_GetSelEnd, METH_VARARGS | METH_KEYWORDS, NULL},
35032          { (char *)"Slider_GetSelStart", (PyCFunction) _wrap_Slider_GetSelStart, METH_VARARGS | METH_KEYWORDS, NULL},
35033          { (char *)"Slider_SetSelection", (PyCFunction) _wrap_Slider_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35034          { (char *)"Slider_GetClassDefaultAttributes", (PyCFunction) _wrap_Slider_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35035          { (char *)"Slider_swigregister", Slider_swigregister, METH_VARARGS, NULL},
35036          { (char *)"new_ToggleButton", (PyCFunction) _wrap_new_ToggleButton, METH_VARARGS | METH_KEYWORDS, NULL},
35037          { (char *)"new_PreToggleButton", (PyCFunction) _wrap_new_PreToggleButton, METH_VARARGS | METH_KEYWORDS, NULL},
35038          { (char *)"ToggleButton_Create", (PyCFunction) _wrap_ToggleButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35039          { (char *)"ToggleButton_SetValue", (PyCFunction) _wrap_ToggleButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35040          { (char *)"ToggleButton_GetValue", (PyCFunction) _wrap_ToggleButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35041          { (char *)"ToggleButton_SetLabel", (PyCFunction) _wrap_ToggleButton_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35042          { (char *)"ToggleButton_GetClassDefaultAttributes", (PyCFunction) _wrap_ToggleButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35043          { (char *)"ToggleButton_swigregister", ToggleButton_swigregister, METH_VARARGS, NULL},
35044          { (char *)"BookCtrlBase_GetPageCount", (PyCFunction) _wrap_BookCtrlBase_GetPageCount, METH_VARARGS | METH_KEYWORDS, NULL},
35045          { (char *)"BookCtrlBase_GetPage", (PyCFunction) _wrap_BookCtrlBase_GetPage, METH_VARARGS | METH_KEYWORDS, NULL},
35046          { (char *)"BookCtrlBase_GetCurrentPage", (PyCFunction) _wrap_BookCtrlBase_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
35047          { (char *)"BookCtrlBase_GetSelection", (PyCFunction) _wrap_BookCtrlBase_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35048          { (char *)"BookCtrlBase_SetPageText", (PyCFunction) _wrap_BookCtrlBase_SetPageText, METH_VARARGS | METH_KEYWORDS, NULL},
35049          { (char *)"BookCtrlBase_GetPageText", (PyCFunction) _wrap_BookCtrlBase_GetPageText, METH_VARARGS | METH_KEYWORDS, NULL},
35050          { (char *)"BookCtrlBase_SetImageList", (PyCFunction) _wrap_BookCtrlBase_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35051          { (char *)"BookCtrlBase_AssignImageList", (PyCFunction) _wrap_BookCtrlBase_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35052          { (char *)"BookCtrlBase_GetImageList", (PyCFunction) _wrap_BookCtrlBase_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35053          { (char *)"BookCtrlBase_GetPageImage", (PyCFunction) _wrap_BookCtrlBase_GetPageImage, METH_VARARGS | METH_KEYWORDS, NULL},
35054          { (char *)"BookCtrlBase_SetPageImage", (PyCFunction) _wrap_BookCtrlBase_SetPageImage, METH_VARARGS | METH_KEYWORDS, NULL},
35055          { (char *)"BookCtrlBase_SetPageSize", (PyCFunction) _wrap_BookCtrlBase_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35056          { (char *)"BookCtrlBase_CalcSizeFromPage", (PyCFunction) _wrap_BookCtrlBase_CalcSizeFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
35057          { (char *)"BookCtrlBase_DeletePage", (PyCFunction) _wrap_BookCtrlBase_DeletePage, METH_VARARGS | METH_KEYWORDS, NULL},
35058          { (char *)"BookCtrlBase_RemovePage", (PyCFunction) _wrap_BookCtrlBase_RemovePage, METH_VARARGS | METH_KEYWORDS, NULL},
35059          { (char *)"BookCtrlBase_DeleteAllPages", (PyCFunction) _wrap_BookCtrlBase_DeleteAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
35060          { (char *)"BookCtrlBase_AddPage", (PyCFunction) _wrap_BookCtrlBase_AddPage, METH_VARARGS | METH_KEYWORDS, NULL},
35061          { (char *)"BookCtrlBase_InsertPage", (PyCFunction) _wrap_BookCtrlBase_InsertPage, METH_VARARGS | METH_KEYWORDS, NULL},
35062          { (char *)"BookCtrlBase_SetSelection", (PyCFunction) _wrap_BookCtrlBase_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35063          { (char *)"BookCtrlBase_AdvanceSelection", (PyCFunction) _wrap_BookCtrlBase_AdvanceSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35064          { (char *)"BookCtrlBase_GetClassDefaultAttributes", (PyCFunction) _wrap_BookCtrlBase_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35065          { (char *)"BookCtrlBase_swigregister", BookCtrlBase_swigregister, METH_VARARGS, NULL},
35066          { (char *)"new_BookCtrlBaseEvent", (PyCFunction) _wrap_new_BookCtrlBaseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35067          { (char *)"BookCtrlBaseEvent_GetSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35068          { (char *)"BookCtrlBaseEvent_SetSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35069          { (char *)"BookCtrlBaseEvent_GetOldSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_GetOldSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35070          { (char *)"BookCtrlBaseEvent_SetOldSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_SetOldSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35071          { (char *)"BookCtrlBaseEvent_swigregister", BookCtrlBaseEvent_swigregister, METH_VARARGS, NULL},
35072          { (char *)"new_Notebook", (PyCFunction) _wrap_new_Notebook, METH_VARARGS | METH_KEYWORDS, NULL},
35073          { (char *)"new_PreNotebook", (PyCFunction) _wrap_new_PreNotebook, METH_VARARGS | METH_KEYWORDS, NULL},
35074          { (char *)"Notebook_Create", (PyCFunction) _wrap_Notebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35075          { (char *)"Notebook_GetRowCount", (PyCFunction) _wrap_Notebook_GetRowCount, METH_VARARGS | METH_KEYWORDS, NULL},
35076          { (char *)"Notebook_SetPadding", (PyCFunction) _wrap_Notebook_SetPadding, METH_VARARGS | METH_KEYWORDS, NULL},
35077          { (char *)"Notebook_SetTabSize", (PyCFunction) _wrap_Notebook_SetTabSize, METH_VARARGS | METH_KEYWORDS, NULL},
35078          { (char *)"Notebook_HitTest", (PyCFunction) _wrap_Notebook_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35079          { (char *)"Notebook_CalcSizeFromPage", (PyCFunction) _wrap_Notebook_CalcSizeFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
35080          { (char *)"Notebook_GetClassDefaultAttributes", (PyCFunction) _wrap_Notebook_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35081          { (char *)"Notebook_swigregister", Notebook_swigregister, METH_VARARGS, NULL},
35082          { (char *)"new_NotebookEvent", (PyCFunction) _wrap_new_NotebookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35083          { (char *)"NotebookEvent_swigregister", NotebookEvent_swigregister, METH_VARARGS, NULL},
35084          { (char *)"new_Listbook", (PyCFunction) _wrap_new_Listbook, METH_VARARGS | METH_KEYWORDS, NULL},
35085          { (char *)"new_PreListbook", (PyCFunction) _wrap_new_PreListbook, METH_VARARGS | METH_KEYWORDS, NULL},
35086          { (char *)"Listbook_Create", (PyCFunction) _wrap_Listbook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35087          { (char *)"Listbook_IsVertical", (PyCFunction) _wrap_Listbook_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35088          { (char *)"Listbook_GetListView", (PyCFunction) _wrap_Listbook_GetListView, METH_VARARGS | METH_KEYWORDS, NULL},
35089          { (char *)"Listbook_swigregister", Listbook_swigregister, METH_VARARGS, NULL},
35090          { (char *)"new_ListbookEvent", (PyCFunction) _wrap_new_ListbookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35091          { (char *)"ListbookEvent_swigregister", ListbookEvent_swigregister, METH_VARARGS, NULL},
35092          { (char *)"new_Choicebook", (PyCFunction) _wrap_new_Choicebook, METH_VARARGS | METH_KEYWORDS, NULL},
35093          { (char *)"new_PreChoicebook", (PyCFunction) _wrap_new_PreChoicebook, METH_VARARGS | METH_KEYWORDS, NULL},
35094          { (char *)"Choicebook_Create", (PyCFunction) _wrap_Choicebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35095          { (char *)"Choicebook_IsVertical", (PyCFunction) _wrap_Choicebook_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35096          { (char *)"Choicebook_DeleteAllPages", (PyCFunction) _wrap_Choicebook_DeleteAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
35097          { (char *)"Choicebook_swigregister", Choicebook_swigregister, METH_VARARGS, NULL},
35098          { (char *)"new_ChoicebookEvent", (PyCFunction) _wrap_new_ChoicebookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35099          { (char *)"ChoicebookEvent_swigregister", ChoicebookEvent_swigregister, METH_VARARGS, NULL},
35100          { (char *)"new_BookCtrlSizer", (PyCFunction) _wrap_new_BookCtrlSizer, METH_VARARGS | METH_KEYWORDS, NULL},
35101          { (char *)"BookCtrlSizer_RecalcSizes", (PyCFunction) _wrap_BookCtrlSizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
35102          { (char *)"BookCtrlSizer_CalcMin", (PyCFunction) _wrap_BookCtrlSizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
35103          { (char *)"BookCtrlSizer_GetControl", (PyCFunction) _wrap_BookCtrlSizer_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
35104          { (char *)"BookCtrlSizer_swigregister", BookCtrlSizer_swigregister, METH_VARARGS, NULL},
35105          { (char *)"new_NotebookSizer", (PyCFunction) _wrap_new_NotebookSizer, METH_VARARGS | METH_KEYWORDS, NULL},
35106          { (char *)"NotebookSizer_RecalcSizes", (PyCFunction) _wrap_NotebookSizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
35107          { (char *)"NotebookSizer_CalcMin", (PyCFunction) _wrap_NotebookSizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
35108          { (char *)"NotebookSizer_GetNotebook", (PyCFunction) _wrap_NotebookSizer_GetNotebook, METH_VARARGS | METH_KEYWORDS, NULL},
35109          { (char *)"NotebookSizer_swigregister", NotebookSizer_swigregister, METH_VARARGS, NULL},
35110          { (char *)"ToolBarToolBase_GetId", (PyCFunction) _wrap_ToolBarToolBase_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35111          { (char *)"ToolBarToolBase_GetControl", (PyCFunction) _wrap_ToolBarToolBase_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
35112          { (char *)"ToolBarToolBase_GetToolBar", (PyCFunction) _wrap_ToolBarToolBase_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35113          { (char *)"ToolBarToolBase_IsButton", (PyCFunction) _wrap_ToolBarToolBase_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
35114          { (char *)"ToolBarToolBase_IsControl", (PyCFunction) _wrap_ToolBarToolBase_IsControl, METH_VARARGS | METH_KEYWORDS, NULL},
35115          { (char *)"ToolBarToolBase_IsSeparator", (PyCFunction) _wrap_ToolBarToolBase_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35116          { (char *)"ToolBarToolBase_GetStyle", (PyCFunction) _wrap_ToolBarToolBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
35117          { (char *)"ToolBarToolBase_GetKind", (PyCFunction) _wrap_ToolBarToolBase_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
35118          { (char *)"ToolBarToolBase_IsEnabled", (PyCFunction) _wrap_ToolBarToolBase_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
35119          { (char *)"ToolBarToolBase_IsToggled", (PyCFunction) _wrap_ToolBarToolBase_IsToggled, METH_VARARGS | METH_KEYWORDS, NULL},
35120          { (char *)"ToolBarToolBase_CanBeToggled", (PyCFunction) _wrap_ToolBarToolBase_CanBeToggled, METH_VARARGS | METH_KEYWORDS, NULL},
35121          { (char *)"ToolBarToolBase_GetNormalBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35122          { (char *)"ToolBarToolBase_GetDisabledBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35123          { (char *)"ToolBarToolBase_GetBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35124          { (char *)"ToolBarToolBase_GetLabel", (PyCFunction) _wrap_ToolBarToolBase_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35125          { (char *)"ToolBarToolBase_GetShortHelp", (PyCFunction) _wrap_ToolBarToolBase_GetShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35126          { (char *)"ToolBarToolBase_GetLongHelp", (PyCFunction) _wrap_ToolBarToolBase_GetLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35127          { (char *)"ToolBarToolBase_Enable", (PyCFunction) _wrap_ToolBarToolBase_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35128          { (char *)"ToolBarToolBase_Toggle", (PyCFunction) _wrap_ToolBarToolBase_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
35129          { (char *)"ToolBarToolBase_SetToggle", (PyCFunction) _wrap_ToolBarToolBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
35130          { (char *)"ToolBarToolBase_SetShortHelp", (PyCFunction) _wrap_ToolBarToolBase_SetShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35131          { (char *)"ToolBarToolBase_SetLongHelp", (PyCFunction) _wrap_ToolBarToolBase_SetLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35132          { (char *)"ToolBarToolBase_SetNormalBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35133          { (char *)"ToolBarToolBase_SetDisabledBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35134          { (char *)"ToolBarToolBase_SetLabel", (PyCFunction) _wrap_ToolBarToolBase_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35135          { (char *)"ToolBarToolBase_Detach", (PyCFunction) _wrap_ToolBarToolBase_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
35136          { (char *)"ToolBarToolBase_Attach", (PyCFunction) _wrap_ToolBarToolBase_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
35137          { (char *)"ToolBarToolBase_GetClientData", (PyCFunction) _wrap_ToolBarToolBase_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35138          { (char *)"ToolBarToolBase_SetClientData", (PyCFunction) _wrap_ToolBarToolBase_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35139          { (char *)"ToolBarToolBase_swigregister", ToolBarToolBase_swigregister, METH_VARARGS, NULL},
35140          { (char *)"ToolBarBase_DoAddTool", (PyCFunction) _wrap_ToolBarBase_DoAddTool, METH_VARARGS | METH_KEYWORDS, NULL},
35141          { (char *)"ToolBarBase_DoInsertTool", (PyCFunction) _wrap_ToolBarBase_DoInsertTool, METH_VARARGS | METH_KEYWORDS, NULL},
35142          { (char *)"ToolBarBase_AddToolItem", (PyCFunction) _wrap_ToolBarBase_AddToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
35143          { (char *)"ToolBarBase_InsertToolItem", (PyCFunction) _wrap_ToolBarBase_InsertToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
35144          { (char *)"ToolBarBase_AddControl", (PyCFunction) _wrap_ToolBarBase_AddControl, METH_VARARGS | METH_KEYWORDS, NULL},
35145          { (char *)"ToolBarBase_InsertControl", (PyCFunction) _wrap_ToolBarBase_InsertControl, METH_VARARGS | METH_KEYWORDS, NULL},
35146          { (char *)"ToolBarBase_FindControl", (PyCFunction) _wrap_ToolBarBase_FindControl, METH_VARARGS | METH_KEYWORDS, NULL},
35147          { (char *)"ToolBarBase_AddSeparator", (PyCFunction) _wrap_ToolBarBase_AddSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35148          { (char *)"ToolBarBase_InsertSeparator", (PyCFunction) _wrap_ToolBarBase_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35149          { (char *)"ToolBarBase_RemoveTool", (PyCFunction) _wrap_ToolBarBase_RemoveTool, METH_VARARGS | METH_KEYWORDS, NULL},
35150          { (char *)"ToolBarBase_DeleteToolByPos", (PyCFunction) _wrap_ToolBarBase_DeleteToolByPos, METH_VARARGS | METH_KEYWORDS, NULL},
35151          { (char *)"ToolBarBase_DeleteTool", (PyCFunction) _wrap_ToolBarBase_DeleteTool, METH_VARARGS | METH_KEYWORDS, NULL},
35152          { (char *)"ToolBarBase_ClearTools", (PyCFunction) _wrap_ToolBarBase_ClearTools, METH_VARARGS | METH_KEYWORDS, NULL},
35153          { (char *)"ToolBarBase_Realize", (PyCFunction) _wrap_ToolBarBase_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
35154          { (char *)"ToolBarBase_EnableTool", (PyCFunction) _wrap_ToolBarBase_EnableTool, METH_VARARGS | METH_KEYWORDS, NULL},
35155          { (char *)"ToolBarBase_ToggleTool", (PyCFunction) _wrap_ToolBarBase_ToggleTool, METH_VARARGS | METH_KEYWORDS, NULL},
35156          { (char *)"ToolBarBase_SetToggle", (PyCFunction) _wrap_ToolBarBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
35157          { (char *)"ToolBarBase_GetToolClientData", (PyCFunction) _wrap_ToolBarBase_GetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35158          { (char *)"ToolBarBase_SetToolClientData", (PyCFunction) _wrap_ToolBarBase_SetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35159          { (char *)"ToolBarBase_GetToolPos", (PyCFunction) _wrap_ToolBarBase_GetToolPos, METH_VARARGS | METH_KEYWORDS, NULL},
35160          { (char *)"ToolBarBase_GetToolState", (PyCFunction) _wrap_ToolBarBase_GetToolState, METH_VARARGS | METH_KEYWORDS, NULL},
35161          { (char *)"ToolBarBase_GetToolEnabled", (PyCFunction) _wrap_ToolBarBase_GetToolEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
35162          { (char *)"ToolBarBase_SetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_SetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35163          { (char *)"ToolBarBase_GetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_GetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35164          { (char *)"ToolBarBase_SetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_SetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35165          { (char *)"ToolBarBase_GetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_GetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35166          { (char *)"ToolBarBase_SetMarginsXY", (PyCFunction) _wrap_ToolBarBase_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
35167          { (char *)"ToolBarBase_SetMargins", (PyCFunction) _wrap_ToolBarBase_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35168          { (char *)"ToolBarBase_SetToolPacking", (PyCFunction) _wrap_ToolBarBase_SetToolPacking, METH_VARARGS | METH_KEYWORDS, NULL},
35169          { (char *)"ToolBarBase_SetToolSeparation", (PyCFunction) _wrap_ToolBarBase_SetToolSeparation, METH_VARARGS | METH_KEYWORDS, NULL},
35170          { (char *)"ToolBarBase_GetToolMargins", (PyCFunction) _wrap_ToolBarBase_GetToolMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35171          { (char *)"ToolBarBase_GetMargins", (PyCFunction) _wrap_ToolBarBase_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35172          { (char *)"ToolBarBase_GetToolPacking", (PyCFunction) _wrap_ToolBarBase_GetToolPacking, METH_VARARGS | METH_KEYWORDS, NULL},
35173          { (char *)"ToolBarBase_GetToolSeparation", (PyCFunction) _wrap_ToolBarBase_GetToolSeparation, METH_VARARGS | METH_KEYWORDS, NULL},
35174          { (char *)"ToolBarBase_SetRows", (PyCFunction) _wrap_ToolBarBase_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
35175          { (char *)"ToolBarBase_SetMaxRowsCols", (PyCFunction) _wrap_ToolBarBase_SetMaxRowsCols, METH_VARARGS | METH_KEYWORDS, NULL},
35176          { (char *)"ToolBarBase_GetMaxRows", (PyCFunction) _wrap_ToolBarBase_GetMaxRows, METH_VARARGS | METH_KEYWORDS, NULL},
35177          { (char *)"ToolBarBase_GetMaxCols", (PyCFunction) _wrap_ToolBarBase_GetMaxCols, METH_VARARGS | METH_KEYWORDS, NULL},
35178          { (char *)"ToolBarBase_SetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_SetToolBitmapSize, METH_VARARGS | METH_KEYWORDS, NULL},
35179          { (char *)"ToolBarBase_GetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_GetToolBitmapSize, METH_VARARGS | METH_KEYWORDS, NULL},
35180          { (char *)"ToolBarBase_GetToolSize", (PyCFunction) _wrap_ToolBarBase_GetToolSize, METH_VARARGS | METH_KEYWORDS, NULL},
35181          { (char *)"ToolBarBase_FindToolForPosition", (PyCFunction) _wrap_ToolBarBase_FindToolForPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35182          { (char *)"ToolBarBase_FindById", (PyCFunction) _wrap_ToolBarBase_FindById, METH_VARARGS | METH_KEYWORDS, NULL},
35183          { (char *)"ToolBarBase_IsVertical", (PyCFunction) _wrap_ToolBarBase_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35184          { (char *)"ToolBarBase_swigregister", ToolBarBase_swigregister, METH_VARARGS, NULL},
35185          { (char *)"new_ToolBar", (PyCFunction) _wrap_new_ToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35186          { (char *)"new_PreToolBar", (PyCFunction) _wrap_new_PreToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35187          { (char *)"ToolBar_Create", (PyCFunction) _wrap_ToolBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35188          { (char *)"ToolBar_FindToolForPosition", (PyCFunction) _wrap_ToolBar_FindToolForPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35189          { (char *)"ToolBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ToolBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35190          { (char *)"ToolBar_swigregister", ToolBar_swigregister, METH_VARARGS, NULL},
35191          { (char *)"new_ListItemAttr", (PyCFunction) _wrap_new_ListItemAttr, METH_VARARGS | METH_KEYWORDS, NULL},
35192          { (char *)"ListItemAttr_SetTextColour", (PyCFunction) _wrap_ListItemAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35193          { (char *)"ListItemAttr_SetBackgroundColour", (PyCFunction) _wrap_ListItemAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35194          { (char *)"ListItemAttr_SetFont", (PyCFunction) _wrap_ListItemAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35195          { (char *)"ListItemAttr_HasTextColour", (PyCFunction) _wrap_ListItemAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35196          { (char *)"ListItemAttr_HasBackgroundColour", (PyCFunction) _wrap_ListItemAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35197          { (char *)"ListItemAttr_HasFont", (PyCFunction) _wrap_ListItemAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
35198          { (char *)"ListItemAttr_GetTextColour", (PyCFunction) _wrap_ListItemAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35199          { (char *)"ListItemAttr_GetBackgroundColour", (PyCFunction) _wrap_ListItemAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35200          { (char *)"ListItemAttr_GetFont", (PyCFunction) _wrap_ListItemAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35201          { (char *)"ListItemAttr_Destroy", (PyCFunction) _wrap_ListItemAttr_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35202          { (char *)"ListItemAttr_swigregister", ListItemAttr_swigregister, METH_VARARGS, NULL},
35203          { (char *)"new_ListItem", (PyCFunction) _wrap_new_ListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35204          { (char *)"delete_ListItem", (PyCFunction) _wrap_delete_ListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35205          { (char *)"ListItem_Clear", (PyCFunction) _wrap_ListItem_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
35206          { (char *)"ListItem_ClearAttributes", (PyCFunction) _wrap_ListItem_ClearAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35207          { (char *)"ListItem_SetMask", (PyCFunction) _wrap_ListItem_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35208          { (char *)"ListItem_SetId", (PyCFunction) _wrap_ListItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
35209          { (char *)"ListItem_SetColumn", (PyCFunction) _wrap_ListItem_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35210          { (char *)"ListItem_SetState", (PyCFunction) _wrap_ListItem_SetState, METH_VARARGS | METH_KEYWORDS, NULL},
35211          { (char *)"ListItem_SetStateMask", (PyCFunction) _wrap_ListItem_SetStateMask, METH_VARARGS | METH_KEYWORDS, NULL},
35212          { (char *)"ListItem_SetText", (PyCFunction) _wrap_ListItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
35213          { (char *)"ListItem_SetImage", (PyCFunction) _wrap_ListItem_SetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35214          { (char *)"ListItem_SetData", (PyCFunction) _wrap_ListItem_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
35215          { (char *)"ListItem_SetWidth", (PyCFunction) _wrap_ListItem_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35216          { (char *)"ListItem_SetAlign", (PyCFunction) _wrap_ListItem_SetAlign, METH_VARARGS | METH_KEYWORDS, NULL},
35217          { (char *)"ListItem_SetTextColour", (PyCFunction) _wrap_ListItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35218          { (char *)"ListItem_SetBackgroundColour", (PyCFunction) _wrap_ListItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35219          { (char *)"ListItem_SetFont", (PyCFunction) _wrap_ListItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35220          { (char *)"ListItem_GetMask", (PyCFunction) _wrap_ListItem_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35221          { (char *)"ListItem_GetId", (PyCFunction) _wrap_ListItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35222          { (char *)"ListItem_GetColumn", (PyCFunction) _wrap_ListItem_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35223          { (char *)"ListItem_GetState", (PyCFunction) _wrap_ListItem_GetState, METH_VARARGS | METH_KEYWORDS, NULL},
35224          { (char *)"ListItem_GetText", (PyCFunction) _wrap_ListItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
35225          { (char *)"ListItem_GetImage", (PyCFunction) _wrap_ListItem_GetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35226          { (char *)"ListItem_GetData", (PyCFunction) _wrap_ListItem_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35227          { (char *)"ListItem_GetWidth", (PyCFunction) _wrap_ListItem_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35228          { (char *)"ListItem_GetAlign", (PyCFunction) _wrap_ListItem_GetAlign, METH_VARARGS | METH_KEYWORDS, NULL},
35229          { (char *)"ListItem_GetAttributes", (PyCFunction) _wrap_ListItem_GetAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35230          { (char *)"ListItem_HasAttributes", (PyCFunction) _wrap_ListItem_HasAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35231          { (char *)"ListItem_GetTextColour", (PyCFunction) _wrap_ListItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35232          { (char *)"ListItem_GetBackgroundColour", (PyCFunction) _wrap_ListItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35233          { (char *)"ListItem_GetFont", (PyCFunction) _wrap_ListItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35234          { (char *)"ListItem_m_mask_set", (PyCFunction) _wrap_ListItem_m_mask_set, METH_VARARGS | METH_KEYWORDS, NULL},
35235          { (char *)"ListItem_m_mask_get", (PyCFunction) _wrap_ListItem_m_mask_get, METH_VARARGS | METH_KEYWORDS, NULL},
35236          { (char *)"ListItem_m_itemId_set", (PyCFunction) _wrap_ListItem_m_itemId_set, METH_VARARGS | METH_KEYWORDS, NULL},
35237          { (char *)"ListItem_m_itemId_get", (PyCFunction) _wrap_ListItem_m_itemId_get, METH_VARARGS | METH_KEYWORDS, NULL},
35238          { (char *)"ListItem_m_col_set", (PyCFunction) _wrap_ListItem_m_col_set, METH_VARARGS | METH_KEYWORDS, NULL},
35239          { (char *)"ListItem_m_col_get", (PyCFunction) _wrap_ListItem_m_col_get, METH_VARARGS | METH_KEYWORDS, NULL},
35240          { (char *)"ListItem_m_state_set", (PyCFunction) _wrap_ListItem_m_state_set, METH_VARARGS | METH_KEYWORDS, NULL},
35241          { (char *)"ListItem_m_state_get", (PyCFunction) _wrap_ListItem_m_state_get, METH_VARARGS | METH_KEYWORDS, NULL},
35242          { (char *)"ListItem_m_stateMask_set", (PyCFunction) _wrap_ListItem_m_stateMask_set, METH_VARARGS | METH_KEYWORDS, NULL},
35243          { (char *)"ListItem_m_stateMask_get", (PyCFunction) _wrap_ListItem_m_stateMask_get, METH_VARARGS | METH_KEYWORDS, NULL},
35244          { (char *)"ListItem_m_text_set", (PyCFunction) _wrap_ListItem_m_text_set, METH_VARARGS | METH_KEYWORDS, NULL},
35245          { (char *)"ListItem_m_text_get", (PyCFunction) _wrap_ListItem_m_text_get, METH_VARARGS | METH_KEYWORDS, NULL},
35246          { (char *)"ListItem_m_image_set", (PyCFunction) _wrap_ListItem_m_image_set, METH_VARARGS | METH_KEYWORDS, NULL},
35247          { (char *)"ListItem_m_image_get", (PyCFunction) _wrap_ListItem_m_image_get, METH_VARARGS | METH_KEYWORDS, NULL},
35248          { (char *)"ListItem_m_data_set", (PyCFunction) _wrap_ListItem_m_data_set, METH_VARARGS | METH_KEYWORDS, NULL},
35249          { (char *)"ListItem_m_data_get", (PyCFunction) _wrap_ListItem_m_data_get, METH_VARARGS | METH_KEYWORDS, NULL},
35250          { (char *)"ListItem_m_format_set", (PyCFunction) _wrap_ListItem_m_format_set, METH_VARARGS | METH_KEYWORDS, NULL},
35251          { (char *)"ListItem_m_format_get", (PyCFunction) _wrap_ListItem_m_format_get, METH_VARARGS | METH_KEYWORDS, NULL},
35252          { (char *)"ListItem_m_width_set", (PyCFunction) _wrap_ListItem_m_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
35253          { (char *)"ListItem_m_width_get", (PyCFunction) _wrap_ListItem_m_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
35254          { (char *)"ListItem_swigregister", ListItem_swigregister, METH_VARARGS, NULL},
35255          { (char *)"new_ListEvent", (PyCFunction) _wrap_new_ListEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35256          { (char *)"ListEvent_m_code_set", (PyCFunction) _wrap_ListEvent_m_code_set, METH_VARARGS | METH_KEYWORDS, NULL},
35257          { (char *)"ListEvent_m_code_get", (PyCFunction) _wrap_ListEvent_m_code_get, METH_VARARGS | METH_KEYWORDS, NULL},
35258          { (char *)"ListEvent_m_oldItemIndex_set", (PyCFunction) _wrap_ListEvent_m_oldItemIndex_set, METH_VARARGS | METH_KEYWORDS, NULL},
35259          { (char *)"ListEvent_m_oldItemIndex_get", (PyCFunction) _wrap_ListEvent_m_oldItemIndex_get, METH_VARARGS | METH_KEYWORDS, NULL},
35260          { (char *)"ListEvent_m_itemIndex_set", (PyCFunction) _wrap_ListEvent_m_itemIndex_set, METH_VARARGS | METH_KEYWORDS, NULL},
35261          { (char *)"ListEvent_m_itemIndex_get", (PyCFunction) _wrap_ListEvent_m_itemIndex_get, METH_VARARGS | METH_KEYWORDS, NULL},
35262          { (char *)"ListEvent_m_col_set", (PyCFunction) _wrap_ListEvent_m_col_set, METH_VARARGS | METH_KEYWORDS, NULL},
35263          { (char *)"ListEvent_m_col_get", (PyCFunction) _wrap_ListEvent_m_col_get, METH_VARARGS | METH_KEYWORDS, NULL},
35264          { (char *)"ListEvent_m_pointDrag_set", (PyCFunction) _wrap_ListEvent_m_pointDrag_set, METH_VARARGS | METH_KEYWORDS, NULL},
35265          { (char *)"ListEvent_m_pointDrag_get", (PyCFunction) _wrap_ListEvent_m_pointDrag_get, METH_VARARGS | METH_KEYWORDS, NULL},
35266          { (char *)"ListEvent_m_item_get", (PyCFunction) _wrap_ListEvent_m_item_get, METH_VARARGS | METH_KEYWORDS, NULL},
35267          { (char *)"ListEvent_GetKeyCode", (PyCFunction) _wrap_ListEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
35268          { (char *)"ListEvent_GetIndex", (PyCFunction) _wrap_ListEvent_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35269          { (char *)"ListEvent_GetColumn", (PyCFunction) _wrap_ListEvent_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35270          { (char *)"ListEvent_GetPoint", (PyCFunction) _wrap_ListEvent_GetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35271          { (char *)"ListEvent_GetLabel", (PyCFunction) _wrap_ListEvent_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35272          { (char *)"ListEvent_GetText", (PyCFunction) _wrap_ListEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
35273          { (char *)"ListEvent_GetImage", (PyCFunction) _wrap_ListEvent_GetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35274          { (char *)"ListEvent_GetData", (PyCFunction) _wrap_ListEvent_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35275          { (char *)"ListEvent_GetMask", (PyCFunction) _wrap_ListEvent_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35276          { (char *)"ListEvent_GetItem", (PyCFunction) _wrap_ListEvent_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35277          { (char *)"ListEvent_GetCacheFrom", (PyCFunction) _wrap_ListEvent_GetCacheFrom, METH_VARARGS | METH_KEYWORDS, NULL},
35278          { (char *)"ListEvent_GetCacheTo", (PyCFunction) _wrap_ListEvent_GetCacheTo, METH_VARARGS | METH_KEYWORDS, NULL},
35279          { (char *)"ListEvent_IsEditCancelled", (PyCFunction) _wrap_ListEvent_IsEditCancelled, METH_VARARGS | METH_KEYWORDS, NULL},
35280          { (char *)"ListEvent_SetEditCanceled", (PyCFunction) _wrap_ListEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
35281          { (char *)"ListEvent_swigregister", ListEvent_swigregister, METH_VARARGS, NULL},
35282          { (char *)"new_ListCtrl", (PyCFunction) _wrap_new_ListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35283          { (char *)"new_PreListCtrl", (PyCFunction) _wrap_new_PreListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35284          { (char *)"ListCtrl_Create", (PyCFunction) _wrap_ListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35285          { (char *)"ListCtrl__setCallbackInfo", (PyCFunction) _wrap_ListCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35286          { (char *)"ListCtrl_SetForegroundColour", (PyCFunction) _wrap_ListCtrl_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35287          { (char *)"ListCtrl_SetBackgroundColour", (PyCFunction) _wrap_ListCtrl_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35288          { (char *)"ListCtrl_GetColumn", (PyCFunction) _wrap_ListCtrl_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35289          { (char *)"ListCtrl_SetColumn", (PyCFunction) _wrap_ListCtrl_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35290          { (char *)"ListCtrl_GetColumnWidth", (PyCFunction) _wrap_ListCtrl_GetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35291          { (char *)"ListCtrl_SetColumnWidth", (PyCFunction) _wrap_ListCtrl_SetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35292          { (char *)"ListCtrl_GetCountPerPage", (PyCFunction) _wrap_ListCtrl_GetCountPerPage, METH_VARARGS | METH_KEYWORDS, NULL},
35293          { (char *)"ListCtrl_GetViewRect", (PyCFunction) _wrap_ListCtrl_GetViewRect, METH_VARARGS | METH_KEYWORDS, NULL},
35294          { (char *)"ListCtrl_GetEditControl", (PyCFunction) _wrap_ListCtrl_GetEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
35295          { (char *)"ListCtrl_GetItem", (PyCFunction) _wrap_ListCtrl_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35296          { (char *)"ListCtrl_SetItem", (PyCFunction) _wrap_ListCtrl_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35297          { (char *)"ListCtrl_SetStringItem", (PyCFunction) _wrap_ListCtrl_SetStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35298          { (char *)"ListCtrl_GetItemState", (PyCFunction) _wrap_ListCtrl_GetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
35299          { (char *)"ListCtrl_SetItemState", (PyCFunction) _wrap_ListCtrl_SetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
35300          { (char *)"ListCtrl_SetItemImage", (PyCFunction) _wrap_ListCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35301          { (char *)"ListCtrl_GetItemText", (PyCFunction) _wrap_ListCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35302          { (char *)"ListCtrl_SetItemText", (PyCFunction) _wrap_ListCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35303          { (char *)"ListCtrl_GetItemData", (PyCFunction) _wrap_ListCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35304          { (char *)"ListCtrl_SetItemData", (PyCFunction) _wrap_ListCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35305          { (char *)"ListCtrl_GetItemPosition", (PyCFunction) _wrap_ListCtrl_GetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35306          { (char *)"ListCtrl_GetItemRect", (PyCFunction) _wrap_ListCtrl_GetItemRect, METH_VARARGS | METH_KEYWORDS, NULL},
35307          { (char *)"ListCtrl_SetItemPosition", (PyCFunction) _wrap_ListCtrl_SetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35308          { (char *)"ListCtrl_GetItemCount", (PyCFunction) _wrap_ListCtrl_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35309          { (char *)"ListCtrl_GetColumnCount", (PyCFunction) _wrap_ListCtrl_GetColumnCount, METH_VARARGS | METH_KEYWORDS, NULL},
35310          { (char *)"ListCtrl_GetItemSpacing", (PyCFunction) _wrap_ListCtrl_GetItemSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35311          { (char *)"ListCtrl_GetSelectedItemCount", (PyCFunction) _wrap_ListCtrl_GetSelectedItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35312          { (char *)"ListCtrl_GetTextColour", (PyCFunction) _wrap_ListCtrl_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35313          { (char *)"ListCtrl_SetTextColour", (PyCFunction) _wrap_ListCtrl_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35314          { (char *)"ListCtrl_GetTopItem", (PyCFunction) _wrap_ListCtrl_GetTopItem, METH_VARARGS | METH_KEYWORDS, NULL},
35315          { (char *)"ListCtrl_SetSingleStyle", (PyCFunction) _wrap_ListCtrl_SetSingleStyle, METH_VARARGS | METH_KEYWORDS, NULL},
35316          { (char *)"ListCtrl_SetWindowStyleFlag", (PyCFunction) _wrap_ListCtrl_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
35317          { (char *)"ListCtrl_GetNextItem", (PyCFunction) _wrap_ListCtrl_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
35318          { (char *)"ListCtrl_GetImageList", (PyCFunction) _wrap_ListCtrl_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35319          { (char *)"ListCtrl_SetImageList", (PyCFunction) _wrap_ListCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35320          { (char *)"ListCtrl_AssignImageList", (PyCFunction) _wrap_ListCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35321          { (char *)"ListCtrl_InReportView", (PyCFunction) _wrap_ListCtrl_InReportView, METH_VARARGS | METH_KEYWORDS, NULL},
35322          { (char *)"ListCtrl_IsVirtual", (PyCFunction) _wrap_ListCtrl_IsVirtual, METH_VARARGS | METH_KEYWORDS, NULL},
35323          { (char *)"ListCtrl_RefreshItem", (PyCFunction) _wrap_ListCtrl_RefreshItem, METH_VARARGS | METH_KEYWORDS, NULL},
35324          { (char *)"ListCtrl_RefreshItems", (PyCFunction) _wrap_ListCtrl_RefreshItems, METH_VARARGS | METH_KEYWORDS, NULL},
35325          { (char *)"ListCtrl_Arrange", (PyCFunction) _wrap_ListCtrl_Arrange, METH_VARARGS | METH_KEYWORDS, NULL},
35326          { (char *)"ListCtrl_DeleteItem", (PyCFunction) _wrap_ListCtrl_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
35327          { (char *)"ListCtrl_DeleteAllItems", (PyCFunction) _wrap_ListCtrl_DeleteAllItems, METH_VARARGS | METH_KEYWORDS, NULL},
35328          { (char *)"ListCtrl_DeleteColumn", (PyCFunction) _wrap_ListCtrl_DeleteColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35329          { (char *)"ListCtrl_DeleteAllColumns", (PyCFunction) _wrap_ListCtrl_DeleteAllColumns, METH_VARARGS | METH_KEYWORDS, NULL},
35330          { (char *)"ListCtrl_ClearAll", (PyCFunction) _wrap_ListCtrl_ClearAll, METH_VARARGS | METH_KEYWORDS, NULL},
35331          { (char *)"ListCtrl_EditLabel", (PyCFunction) _wrap_ListCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35332          { (char *)"ListCtrl_EndEditLabel", (PyCFunction) _wrap_ListCtrl_EndEditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35333          { (char *)"ListCtrl_EnsureVisible", (PyCFunction) _wrap_ListCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35334          { (char *)"ListCtrl_FindItem", (PyCFunction) _wrap_ListCtrl_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
35335          { (char *)"ListCtrl_FindItemData", (PyCFunction) _wrap_ListCtrl_FindItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35336          { (char *)"ListCtrl_FindItemAtPos", (PyCFunction) _wrap_ListCtrl_FindItemAtPos, METH_VARARGS | METH_KEYWORDS, NULL},
35337          { (char *)"ListCtrl_HitTest", (PyCFunction) _wrap_ListCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35338          { (char *)"ListCtrl_InsertItem", (PyCFunction) _wrap_ListCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
35339          { (char *)"ListCtrl_InsertStringItem", (PyCFunction) _wrap_ListCtrl_InsertStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35340          { (char *)"ListCtrl_InsertImageItem", (PyCFunction) _wrap_ListCtrl_InsertImageItem, METH_VARARGS | METH_KEYWORDS, NULL},
35341          { (char *)"ListCtrl_InsertImageStringItem", (PyCFunction) _wrap_ListCtrl_InsertImageStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35342          { (char *)"ListCtrl_InsertColumnInfo", (PyCFunction) _wrap_ListCtrl_InsertColumnInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35343          { (char *)"ListCtrl_InsertColumn", (PyCFunction) _wrap_ListCtrl_InsertColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35344          { (char *)"ListCtrl_SetItemCount", (PyCFunction) _wrap_ListCtrl_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35345          { (char *)"ListCtrl_ScrollList", (PyCFunction) _wrap_ListCtrl_ScrollList, METH_VARARGS | METH_KEYWORDS, NULL},
35346          { (char *)"ListCtrl_SetItemTextColour", (PyCFunction) _wrap_ListCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35347          { (char *)"ListCtrl_GetItemTextColour", (PyCFunction) _wrap_ListCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35348          { (char *)"ListCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35349          { (char *)"ListCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35350          { (char *)"ListCtrl_SortItems", (PyCFunction) _wrap_ListCtrl_SortItems, METH_VARARGS | METH_KEYWORDS, NULL},
35351          { (char *)"ListCtrl_GetMainWindow", (PyCFunction) _wrap_ListCtrl_GetMainWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35352          { (char *)"ListCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_ListCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35353          { (char *)"ListCtrl_swigregister", ListCtrl_swigregister, METH_VARARGS, NULL},
35354          { (char *)"new_ListView", (PyCFunction) _wrap_new_ListView, METH_VARARGS | METH_KEYWORDS, NULL},
35355          { (char *)"new_PreListView", (PyCFunction) _wrap_new_PreListView, METH_VARARGS | METH_KEYWORDS, NULL},
35356          { (char *)"ListView_Create", (PyCFunction) _wrap_ListView_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35357          { (char *)"ListView_Select", (PyCFunction) _wrap_ListView_Select, METH_VARARGS | METH_KEYWORDS, NULL},
35358          { (char *)"ListView_Focus", (PyCFunction) _wrap_ListView_Focus, METH_VARARGS | METH_KEYWORDS, NULL},
35359          { (char *)"ListView_GetFocusedItem", (PyCFunction) _wrap_ListView_GetFocusedItem, METH_VARARGS | METH_KEYWORDS, NULL},
35360          { (char *)"ListView_GetNextSelected", (PyCFunction) _wrap_ListView_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35361          { (char *)"ListView_GetFirstSelected", (PyCFunction) _wrap_ListView_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35362          { (char *)"ListView_IsSelected", (PyCFunction) _wrap_ListView_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35363          { (char *)"ListView_SetColumnImage", (PyCFunction) _wrap_ListView_SetColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
35364          { (char *)"ListView_ClearColumnImage", (PyCFunction) _wrap_ListView_ClearColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
35365          { (char *)"ListView_swigregister", ListView_swigregister, METH_VARARGS, NULL},
35366          { (char *)"new_TreeItemId", (PyCFunction) _wrap_new_TreeItemId, METH_VARARGS | METH_KEYWORDS, NULL},
35367          { (char *)"delete_TreeItemId", (PyCFunction) _wrap_delete_TreeItemId, METH_VARARGS | METH_KEYWORDS, NULL},
35368          { (char *)"TreeItemId_IsOk", (PyCFunction) _wrap_TreeItemId_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
35369          { (char *)"TreeItemId___eq__", (PyCFunction) _wrap_TreeItemId___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
35370          { (char *)"TreeItemId___ne__", (PyCFunction) _wrap_TreeItemId___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
35371          { (char *)"TreeItemId_m_pItem_set", (PyCFunction) _wrap_TreeItemId_m_pItem_set, METH_VARARGS | METH_KEYWORDS, NULL},
35372          { (char *)"TreeItemId_m_pItem_get", (PyCFunction) _wrap_TreeItemId_m_pItem_get, METH_VARARGS | METH_KEYWORDS, NULL},
35373          { (char *)"TreeItemId_swigregister", TreeItemId_swigregister, METH_VARARGS, NULL},
35374          { (char *)"new_TreeItemData", (PyCFunction) _wrap_new_TreeItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35375          { (char *)"TreeItemData_GetData", (PyCFunction) _wrap_TreeItemData_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35376          { (char *)"TreeItemData_SetData", (PyCFunction) _wrap_TreeItemData_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
35377          { (char *)"TreeItemData_GetId", (PyCFunction) _wrap_TreeItemData_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35378          { (char *)"TreeItemData_SetId", (PyCFunction) _wrap_TreeItemData_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
35379          { (char *)"TreeItemData_Destroy", (PyCFunction) _wrap_TreeItemData_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35380          { (char *)"TreeItemData_swigregister", TreeItemData_swigregister, METH_VARARGS, NULL},
35381          { (char *)"new_TreeEvent", (PyCFunction) _wrap_new_TreeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35382          { (char *)"TreeEvent_GetItem", (PyCFunction) _wrap_TreeEvent_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35383          { (char *)"TreeEvent_SetItem", (PyCFunction) _wrap_TreeEvent_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35384          { (char *)"TreeEvent_GetOldItem", (PyCFunction) _wrap_TreeEvent_GetOldItem, METH_VARARGS | METH_KEYWORDS, NULL},
35385          { (char *)"TreeEvent_SetOldItem", (PyCFunction) _wrap_TreeEvent_SetOldItem, METH_VARARGS | METH_KEYWORDS, NULL},
35386          { (char *)"TreeEvent_GetPoint", (PyCFunction) _wrap_TreeEvent_GetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35387          { (char *)"TreeEvent_SetPoint", (PyCFunction) _wrap_TreeEvent_SetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35388          { (char *)"TreeEvent_GetKeyEvent", (PyCFunction) _wrap_TreeEvent_GetKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35389          { (char *)"TreeEvent_GetKeyCode", (PyCFunction) _wrap_TreeEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
35390          { (char *)"TreeEvent_SetKeyEvent", (PyCFunction) _wrap_TreeEvent_SetKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35391          { (char *)"TreeEvent_GetLabel", (PyCFunction) _wrap_TreeEvent_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35392          { (char *)"TreeEvent_SetLabel", (PyCFunction) _wrap_TreeEvent_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35393          { (char *)"TreeEvent_IsEditCancelled", (PyCFunction) _wrap_TreeEvent_IsEditCancelled, METH_VARARGS | METH_KEYWORDS, NULL},
35394          { (char *)"TreeEvent_SetEditCanceled", (PyCFunction) _wrap_TreeEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
35395          { (char *)"TreeEvent_SetToolTip", (PyCFunction) _wrap_TreeEvent_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35396          { (char *)"TreeEvent_swigregister", TreeEvent_swigregister, METH_VARARGS, NULL},
35397          { (char *)"new_TreeCtrl", (PyCFunction) _wrap_new_TreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35398          { (char *)"new_PreTreeCtrl", (PyCFunction) _wrap_new_PreTreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35399          { (char *)"TreeCtrl_Create", (PyCFunction) _wrap_TreeCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35400          { (char *)"TreeCtrl__setCallbackInfo", (PyCFunction) _wrap_TreeCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35401          { (char *)"TreeCtrl_GetCount", (PyCFunction) _wrap_TreeCtrl_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
35402          { (char *)"TreeCtrl_GetIndent", (PyCFunction) _wrap_TreeCtrl_GetIndent, METH_VARARGS | METH_KEYWORDS, NULL},
35403          { (char *)"TreeCtrl_SetIndent", (PyCFunction) _wrap_TreeCtrl_SetIndent, METH_VARARGS | METH_KEYWORDS, NULL},
35404          { (char *)"TreeCtrl_GetSpacing", (PyCFunction) _wrap_TreeCtrl_GetSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35405          { (char *)"TreeCtrl_SetSpacing", (PyCFunction) _wrap_TreeCtrl_SetSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35406          { (char *)"TreeCtrl_GetImageList", (PyCFunction) _wrap_TreeCtrl_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35407          { (char *)"TreeCtrl_GetStateImageList", (PyCFunction) _wrap_TreeCtrl_GetStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35408          { (char *)"TreeCtrl_SetImageList", (PyCFunction) _wrap_TreeCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35409          { (char *)"TreeCtrl_SetStateImageList", (PyCFunction) _wrap_TreeCtrl_SetStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35410          { (char *)"TreeCtrl_AssignImageList", (PyCFunction) _wrap_TreeCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35411          { (char *)"TreeCtrl_AssignStateImageList", (PyCFunction) _wrap_TreeCtrl_AssignStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35412          { (char *)"TreeCtrl_GetItemText", (PyCFunction) _wrap_TreeCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35413          { (char *)"TreeCtrl_GetItemImage", (PyCFunction) _wrap_TreeCtrl_GetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35414          { (char *)"TreeCtrl_GetItemData", (PyCFunction) _wrap_TreeCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35415          { (char *)"TreeCtrl_GetItemPyData", (PyCFunction) _wrap_TreeCtrl_GetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
35416          { (char *)"TreeCtrl_GetItemTextColour", (PyCFunction) _wrap_TreeCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35417          { (char *)"TreeCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35418          { (char *)"TreeCtrl_GetItemFont", (PyCFunction) _wrap_TreeCtrl_GetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
35419          { (char *)"TreeCtrl_SetItemText", (PyCFunction) _wrap_TreeCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35420          { (char *)"TreeCtrl_SetItemImage", (PyCFunction) _wrap_TreeCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35421          { (char *)"TreeCtrl_SetItemData", (PyCFunction) _wrap_TreeCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35422          { (char *)"TreeCtrl_SetItemPyData", (PyCFunction) _wrap_TreeCtrl_SetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
35423          { (char *)"TreeCtrl_SetItemHasChildren", (PyCFunction) _wrap_TreeCtrl_SetItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35424          { (char *)"TreeCtrl_SetItemBold", (PyCFunction) _wrap_TreeCtrl_SetItemBold, METH_VARARGS | METH_KEYWORDS, NULL},
35425          { (char *)"TreeCtrl_SetItemDropHighlight", (PyCFunction) _wrap_TreeCtrl_SetItemDropHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
35426          { (char *)"TreeCtrl_SetItemTextColour", (PyCFunction) _wrap_TreeCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35427          { (char *)"TreeCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35428          { (char *)"TreeCtrl_SetItemFont", (PyCFunction) _wrap_TreeCtrl_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
35429          { (char *)"TreeCtrl_IsVisible", (PyCFunction) _wrap_TreeCtrl_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35430          { (char *)"TreeCtrl_ItemHasChildren", (PyCFunction) _wrap_TreeCtrl_ItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35431          { (char *)"TreeCtrl_IsExpanded", (PyCFunction) _wrap_TreeCtrl_IsExpanded, METH_VARARGS | METH_KEYWORDS, NULL},
35432          { (char *)"TreeCtrl_IsSelected", (PyCFunction) _wrap_TreeCtrl_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35433          { (char *)"TreeCtrl_IsBold", (PyCFunction) _wrap_TreeCtrl_IsBold, METH_VARARGS | METH_KEYWORDS, NULL},
35434          { (char *)"TreeCtrl_GetChildrenCount", (PyCFunction) _wrap_TreeCtrl_GetChildrenCount, METH_VARARGS | METH_KEYWORDS, NULL},
35435          { (char *)"TreeCtrl_GetRootItem", (PyCFunction) _wrap_TreeCtrl_GetRootItem, METH_VARARGS | METH_KEYWORDS, NULL},
35436          { (char *)"TreeCtrl_GetSelection", (PyCFunction) _wrap_TreeCtrl_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35437          { (char *)"TreeCtrl_GetSelections", (PyCFunction) _wrap_TreeCtrl_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
35438          { (char *)"TreeCtrl_GetItemParent", (PyCFunction) _wrap_TreeCtrl_GetItemParent, METH_VARARGS | METH_KEYWORDS, NULL},
35439          { (char *)"TreeCtrl_GetFirstChild", (PyCFunction) _wrap_TreeCtrl_GetFirstChild, METH_VARARGS | METH_KEYWORDS, NULL},
35440          { (char *)"TreeCtrl_GetNextChild", (PyCFunction) _wrap_TreeCtrl_GetNextChild, METH_VARARGS | METH_KEYWORDS, NULL},
35441          { (char *)"TreeCtrl_GetLastChild", (PyCFunction) _wrap_TreeCtrl_GetLastChild, METH_VARARGS | METH_KEYWORDS, NULL},
35442          { (char *)"TreeCtrl_GetNextSibling", (PyCFunction) _wrap_TreeCtrl_GetNextSibling, METH_VARARGS | METH_KEYWORDS, NULL},
35443          { (char *)"TreeCtrl_GetPrevSibling", (PyCFunction) _wrap_TreeCtrl_GetPrevSibling, METH_VARARGS | METH_KEYWORDS, NULL},
35444          { (char *)"TreeCtrl_GetFirstVisibleItem", (PyCFunction) _wrap_TreeCtrl_GetFirstVisibleItem, METH_VARARGS | METH_KEYWORDS, NULL},
35445          { (char *)"TreeCtrl_GetNextVisible", (PyCFunction) _wrap_TreeCtrl_GetNextVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35446          { (char *)"TreeCtrl_GetPrevVisible", (PyCFunction) _wrap_TreeCtrl_GetPrevVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35447          { (char *)"TreeCtrl_AddRoot", (PyCFunction) _wrap_TreeCtrl_AddRoot, METH_VARARGS | METH_KEYWORDS, NULL},
35448          { (char *)"TreeCtrl_PrependItem", (PyCFunction) _wrap_TreeCtrl_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
35449          { (char *)"TreeCtrl_InsertItem", (PyCFunction) _wrap_TreeCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
35450          { (char *)"TreeCtrl_InsertItemBefore", (PyCFunction) _wrap_TreeCtrl_InsertItemBefore, METH_VARARGS | METH_KEYWORDS, NULL},
35451          { (char *)"TreeCtrl_AppendItem", (PyCFunction) _wrap_TreeCtrl_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
35452          { (char *)"TreeCtrl_Delete", (PyCFunction) _wrap_TreeCtrl_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
35453          { (char *)"TreeCtrl_DeleteChildren", (PyCFunction) _wrap_TreeCtrl_DeleteChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35454          { (char *)"TreeCtrl_DeleteAllItems", (PyCFunction) _wrap_TreeCtrl_DeleteAllItems, METH_VARARGS | METH_KEYWORDS, NULL},
35455          { (char *)"TreeCtrl_Expand", (PyCFunction) _wrap_TreeCtrl_Expand, METH_VARARGS | METH_KEYWORDS, NULL},
35456          { (char *)"TreeCtrl_Collapse", (PyCFunction) _wrap_TreeCtrl_Collapse, METH_VARARGS | METH_KEYWORDS, NULL},
35457          { (char *)"TreeCtrl_CollapseAndReset", (PyCFunction) _wrap_TreeCtrl_CollapseAndReset, METH_VARARGS | METH_KEYWORDS, NULL},
35458          { (char *)"TreeCtrl_Toggle", (PyCFunction) _wrap_TreeCtrl_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
35459          { (char *)"TreeCtrl_Unselect", (PyCFunction) _wrap_TreeCtrl_Unselect, METH_VARARGS | METH_KEYWORDS, NULL},
35460          { (char *)"TreeCtrl_UnselectItem", (PyCFunction) _wrap_TreeCtrl_UnselectItem, METH_VARARGS | METH_KEYWORDS, NULL},
35461          { (char *)"TreeCtrl_UnselectAll", (PyCFunction) _wrap_TreeCtrl_UnselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
35462          { (char *)"TreeCtrl_SelectItem", (PyCFunction) _wrap_TreeCtrl_SelectItem, METH_VARARGS | METH_KEYWORDS, NULL},
35463          { (char *)"TreeCtrl_ToggleItemSelection", (PyCFunction) _wrap_TreeCtrl_ToggleItemSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35464          { (char *)"TreeCtrl_EnsureVisible", (PyCFunction) _wrap_TreeCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35465          { (char *)"TreeCtrl_ScrollTo", (PyCFunction) _wrap_TreeCtrl_ScrollTo, METH_VARARGS | METH_KEYWORDS, NULL},
35466          { (char *)"TreeCtrl_EditLabel", (PyCFunction) _wrap_TreeCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35467          { (char *)"TreeCtrl_GetEditControl", (PyCFunction) _wrap_TreeCtrl_GetEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
35468          { (char *)"TreeCtrl_EndEditLabel", (PyCFunction) _wrap_TreeCtrl_EndEditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35469          { (char *)"TreeCtrl_SortChildren", (PyCFunction) _wrap_TreeCtrl_SortChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35470          { (char *)"TreeCtrl_HitTest", (PyCFunction) _wrap_TreeCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35471          { (char *)"TreeCtrl_GetBoundingRect", (PyCFunction) _wrap_TreeCtrl_GetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
35472          { (char *)"TreeCtrl_SetState", (PyCFunction) _wrap_TreeCtrl_SetState, METH_VARARGS | METH_KEYWORDS, NULL},
35473          { (char *)"TreeCtrl_GetState", (PyCFunction) _wrap_TreeCtrl_GetState, METH_VARARGS | METH_KEYWORDS, NULL},
35474          { (char *)"TreeCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TreeCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35475          { (char *)"TreeCtrl_swigregister", TreeCtrl_swigregister, METH_VARARGS, NULL},
35476          { (char *)"new_GenericDirCtrl", (PyCFunction) _wrap_new_GenericDirCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35477          { (char *)"new_PreGenericDirCtrl", (PyCFunction) _wrap_new_PreGenericDirCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35478          { (char *)"GenericDirCtrl_Create", (PyCFunction) _wrap_GenericDirCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35479          { (char *)"GenericDirCtrl_ExpandPath", (PyCFunction) _wrap_GenericDirCtrl_ExpandPath, METH_VARARGS | METH_KEYWORDS, NULL},
35480          { (char *)"GenericDirCtrl_GetDefaultPath", (PyCFunction) _wrap_GenericDirCtrl_GetDefaultPath, METH_VARARGS | METH_KEYWORDS, NULL},
35481          { (char *)"GenericDirCtrl_SetDefaultPath", (PyCFunction) _wrap_GenericDirCtrl_SetDefaultPath, METH_VARARGS | METH_KEYWORDS, NULL},
35482          { (char *)"GenericDirCtrl_GetPath", (PyCFunction) _wrap_GenericDirCtrl_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
35483          { (char *)"GenericDirCtrl_GetFilePath", (PyCFunction) _wrap_GenericDirCtrl_GetFilePath, METH_VARARGS | METH_KEYWORDS, NULL},
35484          { (char *)"GenericDirCtrl_SetPath", (PyCFunction) _wrap_GenericDirCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
35485          { (char *)"GenericDirCtrl_ShowHidden", (PyCFunction) _wrap_GenericDirCtrl_ShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
35486          { (char *)"GenericDirCtrl_GetShowHidden", (PyCFunction) _wrap_GenericDirCtrl_GetShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
35487          { (char *)"GenericDirCtrl_GetFilter", (PyCFunction) _wrap_GenericDirCtrl_GetFilter, METH_VARARGS | METH_KEYWORDS, NULL},
35488          { (char *)"GenericDirCtrl_SetFilter", (PyCFunction) _wrap_GenericDirCtrl_SetFilter, METH_VARARGS | METH_KEYWORDS, NULL},
35489          { (char *)"GenericDirCtrl_GetFilterIndex", (PyCFunction) _wrap_GenericDirCtrl_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35490          { (char *)"GenericDirCtrl_SetFilterIndex", (PyCFunction) _wrap_GenericDirCtrl_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35491          { (char *)"GenericDirCtrl_GetRootId", (PyCFunction) _wrap_GenericDirCtrl_GetRootId, METH_VARARGS | METH_KEYWORDS, NULL},
35492          { (char *)"GenericDirCtrl_GetTreeCtrl", (PyCFunction) _wrap_GenericDirCtrl_GetTreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35493          { (char *)"GenericDirCtrl_GetFilterListCtrl", (PyCFunction) _wrap_GenericDirCtrl_GetFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35494          { (char *)"GenericDirCtrl_FindChild", (PyCFunction) _wrap_GenericDirCtrl_FindChild, METH_VARARGS | METH_KEYWORDS, NULL},
35495          { (char *)"GenericDirCtrl_DoResize", (PyCFunction) _wrap_GenericDirCtrl_DoResize, METH_VARARGS | METH_KEYWORDS, NULL},
35496          { (char *)"GenericDirCtrl_ReCreateTree", (PyCFunction) _wrap_GenericDirCtrl_ReCreateTree, METH_VARARGS | METH_KEYWORDS, NULL},
35497          { (char *)"GenericDirCtrl_swigregister", GenericDirCtrl_swigregister, METH_VARARGS, NULL},
35498          { (char *)"new_DirFilterListCtrl", (PyCFunction) _wrap_new_DirFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35499          { (char *)"new_PreDirFilterListCtrl", (PyCFunction) _wrap_new_PreDirFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35500          { (char *)"DirFilterListCtrl_Create", (PyCFunction) _wrap_DirFilterListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35501          { (char *)"DirFilterListCtrl_FillFilterList", (PyCFunction) _wrap_DirFilterListCtrl_FillFilterList, METH_VARARGS | METH_KEYWORDS, NULL},
35502          { (char *)"DirFilterListCtrl_swigregister", DirFilterListCtrl_swigregister, METH_VARARGS, NULL},
35503          { (char *)"new_PyControl", (PyCFunction) _wrap_new_PyControl, METH_VARARGS | METH_KEYWORDS, NULL},
35504          { (char *)"new_PrePyControl", (PyCFunction) _wrap_new_PrePyControl, METH_VARARGS | METH_KEYWORDS, NULL},
35505          { (char *)"PyControl__setCallbackInfo", (PyCFunction) _wrap_PyControl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35506          { (char *)"PyControl_SetBestSize", (PyCFunction) _wrap_PyControl_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
35507          { (char *)"PyControl_base_DoMoveWindow", (PyCFunction) _wrap_PyControl_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35508          { (char *)"PyControl_base_DoSetSize", (PyCFunction) _wrap_PyControl_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35509          { (char *)"PyControl_base_DoSetClientSize", (PyCFunction) _wrap_PyControl_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
35510          { (char *)"PyControl_base_DoSetVirtualSize", (PyCFunction) _wrap_PyControl_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
35511          { (char *)"PyControl_base_DoGetSize", (PyCFunction) _wrap_PyControl_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35512          { (char *)"PyControl_base_DoGetClientSize", (PyCFunction) _wrap_PyControl_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
35513          { (char *)"PyControl_base_DoGetPosition", (PyCFunction) _wrap_PyControl_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35514          { (char *)"PyControl_base_DoGetVirtualSize", (PyCFunction) _wrap_PyControl_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
35515          { (char *)"PyControl_base_DoGetBestSize", (PyCFunction) _wrap_PyControl_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
35516          { (char *)"PyControl_base_InitDialog", (PyCFunction) _wrap_PyControl_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
35517          { (char *)"PyControl_base_TransferDataToWindow", (PyCFunction) _wrap_PyControl_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35518          { (char *)"PyControl_base_TransferDataFromWindow", (PyCFunction) _wrap_PyControl_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35519          { (char *)"PyControl_base_Validate", (PyCFunction) _wrap_PyControl_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
35520          { (char *)"PyControl_base_AcceptsFocus", (PyCFunction) _wrap_PyControl_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
35521          { (char *)"PyControl_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyControl_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
35522          { (char *)"PyControl_base_GetMaxSize", (PyCFunction) _wrap_PyControl_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
35523          { (char *)"PyControl_base_AddChild", (PyCFunction) _wrap_PyControl_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
35524          { (char *)"PyControl_base_RemoveChild", (PyCFunction) _wrap_PyControl_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
35525          { (char *)"PyControl_base_ShouldInheritColours", (PyCFunction) _wrap_PyControl_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
35526          { (char *)"PyControl_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyControl_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
35527          { (char *)"PyControl_base_GetDefaultAttributes", (PyCFunction) _wrap_PyControl_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35528          { (char *)"PyControl_swigregister", PyControl_swigregister, METH_VARARGS, NULL},
35529          { (char *)"new_HelpEvent", (PyCFunction) _wrap_new_HelpEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35530          { (char *)"HelpEvent_GetPosition", (PyCFunction) _wrap_HelpEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35531          { (char *)"HelpEvent_SetPosition", (PyCFunction) _wrap_HelpEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35532          { (char *)"HelpEvent_GetLink", (PyCFunction) _wrap_HelpEvent_GetLink, METH_VARARGS | METH_KEYWORDS, NULL},
35533          { (char *)"HelpEvent_SetLink", (PyCFunction) _wrap_HelpEvent_SetLink, METH_VARARGS | METH_KEYWORDS, NULL},
35534          { (char *)"HelpEvent_GetTarget", (PyCFunction) _wrap_HelpEvent_GetTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35535          { (char *)"HelpEvent_SetTarget", (PyCFunction) _wrap_HelpEvent_SetTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35536          { (char *)"HelpEvent_swigregister", HelpEvent_swigregister, METH_VARARGS, NULL},
35537          { (char *)"new_ContextHelp", (PyCFunction) _wrap_new_ContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35538          { (char *)"delete_ContextHelp", (PyCFunction) _wrap_delete_ContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35539          { (char *)"ContextHelp_BeginContextHelp", (PyCFunction) _wrap_ContextHelp_BeginContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35540          { (char *)"ContextHelp_EndContextHelp", (PyCFunction) _wrap_ContextHelp_EndContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35541          { (char *)"ContextHelp_swigregister", ContextHelp_swigregister, METH_VARARGS, NULL},
35542          { (char *)"new_ContextHelpButton", (PyCFunction) _wrap_new_ContextHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
35543          { (char *)"ContextHelpButton_swigregister", ContextHelpButton_swigregister, METH_VARARGS, NULL},
35544          { (char *)"HelpProvider_Set", (PyCFunction) _wrap_HelpProvider_Set, METH_VARARGS | METH_KEYWORDS, NULL},
35545          { (char *)"HelpProvider_Get", (PyCFunction) _wrap_HelpProvider_Get, METH_VARARGS | METH_KEYWORDS, NULL},
35546          { (char *)"HelpProvider_GetHelp", (PyCFunction) _wrap_HelpProvider_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35547          { (char *)"HelpProvider_ShowHelp", (PyCFunction) _wrap_HelpProvider_ShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35548          { (char *)"HelpProvider_AddHelp", (PyCFunction) _wrap_HelpProvider_AddHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35549          { (char *)"HelpProvider_AddHelpById", (PyCFunction) _wrap_HelpProvider_AddHelpById, METH_VARARGS | METH_KEYWORDS, NULL},
35550          { (char *)"HelpProvider_RemoveHelp", (PyCFunction) _wrap_HelpProvider_RemoveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35551          { (char *)"HelpProvider_Destroy", (PyCFunction) _wrap_HelpProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35552          { (char *)"HelpProvider_swigregister", HelpProvider_swigregister, METH_VARARGS, NULL},
35553          { (char *)"new_SimpleHelpProvider", (PyCFunction) _wrap_new_SimpleHelpProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35554          { (char *)"SimpleHelpProvider_swigregister", SimpleHelpProvider_swigregister, METH_VARARGS, NULL},
35555          { (char *)"new_DragImage", (PyCFunction) _wrap_new_DragImage, METH_VARARGS | METH_KEYWORDS, NULL},
35556          { (char *)"new_DragIcon", (PyCFunction) _wrap_new_DragIcon, METH_VARARGS | METH_KEYWORDS, NULL},
35557          { (char *)"new_DragString", (PyCFunction) _wrap_new_DragString, METH_VARARGS | METH_KEYWORDS, NULL},
35558          { (char *)"new_DragTreeItem", (PyCFunction) _wrap_new_DragTreeItem, METH_VARARGS | METH_KEYWORDS, NULL},
35559          { (char *)"new_DragListItem", (PyCFunction) _wrap_new_DragListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35560          { (char *)"delete_DragImage", (PyCFunction) _wrap_delete_DragImage, METH_VARARGS | METH_KEYWORDS, NULL},
35561          { (char *)"DragImage_SetBackingBitmap", (PyCFunction) _wrap_DragImage_SetBackingBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35562          { (char *)"DragImage_BeginDrag", (PyCFunction) _wrap_DragImage_BeginDrag, METH_VARARGS | METH_KEYWORDS, NULL},
35563          { (char *)"DragImage_BeginDragBounded", (PyCFunction) _wrap_DragImage_BeginDragBounded, METH_VARARGS | METH_KEYWORDS, NULL},
35564          { (char *)"DragImage_EndDrag", (PyCFunction) _wrap_DragImage_EndDrag, METH_VARARGS | METH_KEYWORDS, NULL},
35565          { (char *)"DragImage_Move", (PyCFunction) _wrap_DragImage_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35566          { (char *)"DragImage_Show", (PyCFunction) _wrap_DragImage_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35567          { (char *)"DragImage_Hide", (PyCFunction) _wrap_DragImage_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
35568          { (char *)"DragImage_GetImageRect", (PyCFunction) _wrap_DragImage_GetImageRect, METH_VARARGS | METH_KEYWORDS, NULL},
35569          { (char *)"DragImage_DoDrawImage", (PyCFunction) _wrap_DragImage_DoDrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
35570          { (char *)"DragImage_UpdateBackingFromWindow", (PyCFunction) _wrap_DragImage_UpdateBackingFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35571          { (char *)"DragImage_RedrawImage", (PyCFunction) _wrap_DragImage_RedrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
35572          { (char *)"DragImage_swigregister", DragImage_swigregister, METH_VARARGS, NULL},
35573          { NULL, NULL, 0, NULL }
35574 };
35575
35576
35577 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
35578
35579 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
35580     return (void *)((wxSizer *)  ((wxBoxSizer *) x));
35581 }
35582 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
35583     return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
35584 }
35585 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
35586     return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
35587 }
35588 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
35589     return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
35590 }
35591 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
35592     return (void *)((wxSizer *)  ((wxGridSizer *) x));
35593 }
35594 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
35595     return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
35596 }
35597 static void *_p_wxNotebookSizerTo_p_wxSizer(void *x) {
35598     return (void *)((wxSizer *)  ((wxNotebookSizer *) x));
35599 }
35600 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
35601     return (void *)((wxSizer *)  ((wxPySizer *) x));
35602 }
35603 static void *_p_wxBookCtrlSizerTo_p_wxSizer(void *x) {
35604     return (void *)((wxSizer *)  ((wxBookCtrlSizer *) x));
35605 }
35606 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
35607     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
35608 }
35609 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
35610     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
35611 }
35612 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
35613     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
35614 }
35615 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
35616     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
35617 }
35618 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
35619     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
35620 }
35621 static void *_p_wxBookCtrlBaseEventTo_p_wxEvent(void *x) {
35622     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
35623 }
35624 static void *_p_wxTreeEventTo_p_wxEvent(void *x) {
35625     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
35626 }
35627 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
35628     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
35629 }
35630 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
35631     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
35632 }
35633 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
35634     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
35635 }
35636 static void *_p_wxTextUrlEventTo_p_wxEvent(void *x) {
35637     return (void *)((wxEvent *) (wxCommandEvent *) ((wxTextUrlEvent *) x));
35638 }
35639 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
35640     return (void *)((wxEvent *)  ((wxPyEvent *) x));
35641 }
35642 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
35643     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
35644 }
35645 static void *_p_wxListEventTo_p_wxEvent(void *x) {
35646     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
35647 }
35648 static void *_p_wxNotebookEventTo_p_wxEvent(void *x) {
35649     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
35650 }
35651 static void *_p_wxListbookEventTo_p_wxEvent(void *x) {
35652     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
35653 }
35654 static void *_p_wxChoicebookEventTo_p_wxEvent(void *x) {
35655     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
35656 }
35657 static void *_p_wxHelpEventTo_p_wxEvent(void *x) {
35658     return (void *)((wxEvent *) (wxCommandEvent *) ((wxHelpEvent *) x));
35659 }
35660 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
35661     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
35662 }
35663 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
35664     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
35665 }
35666 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
35667     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
35668 }
35669 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
35670     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
35671 }
35672 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
35673     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
35674 }
35675 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
35676     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
35677 }
35678 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
35679     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
35680 }
35681 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
35682     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
35683 }
35684 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
35685     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
35686 }
35687 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
35688     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
35689 }
35690 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
35691     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
35692 }
35693 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
35694     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
35695 }
35696 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
35697     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
35698 }
35699 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
35700     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
35701 }
35702 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
35703     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
35704 }
35705 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
35706     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
35707 }
35708 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
35709     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
35710 }
35711 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
35712     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
35713 }
35714 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
35715     return (void *)((wxEvent *)  ((wxShowEvent *) x));
35716 }
35717 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
35718     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
35719 }
35720 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
35721     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
35722 }
35723 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
35724     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
35725 }
35726 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
35727     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
35728 }
35729 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
35730     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
35731 }
35732 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
35733     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
35734 }
35735 static void *_p_wxSpinEventTo_p_wxEvent(void *x) {
35736     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
35737 }
35738 static void *_p_wxComboBoxTo_p_wxItemContainer(void *x) {
35739     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35740 }
35741 static void *_p_wxDirFilterListCtrlTo_p_wxItemContainer(void *x) {
35742     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35743 }
35744 static void *_p_wxChoiceTo_p_wxItemContainer(void *x) {
35745     return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxChoice *) x));
35746 }
35747 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
35748     return (void *)((wxItemContainer *)  ((wxControlWithItems *) x));
35749 }
35750 static void *_p_wxListBoxTo_p_wxItemContainer(void *x) {
35751     return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxListBox *) x));
35752 }
35753 static void *_p_wxCheckListBoxTo_p_wxItemContainer(void *x) {
35754     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
35755 }
35756 static void *_p_wxListViewTo_p_wxPyListCtrl(void *x) {
35757     return (void *)((wxPyListCtrl *)  ((wxListView *) x));
35758 }
35759 static void *_p_wxBookCtrlBaseTo_p_wxControl(void *x) {
35760     return (void *)((wxControl *)  ((wxBookCtrlBase *) x));
35761 }
35762 static void *_p_wxToolBarTo_p_wxControl(void *x) {
35763     return (void *)((wxControl *) (wxToolBarBase *) ((wxToolBar *) x));
35764 }
35765 static void *_p_wxToggleButtonTo_p_wxControl(void *x) {
35766     return (void *)((wxControl *)  ((wxToggleButton *) x));
35767 }
35768 static void *_p_wxRadioButtonTo_p_wxControl(void *x) {
35769     return (void *)((wxControl *)  ((wxRadioButton *) x));
35770 }
35771 static void *_p_wxPyControlTo_p_wxControl(void *x) {
35772     return (void *)((wxControl *)  ((wxPyControl *) x));
35773 }
35774 static void *_p_wxToolBarBaseTo_p_wxControl(void *x) {
35775     return (void *)((wxControl *)  ((wxToolBarBase *) x));
35776 }
35777 static void *_p_wxDirFilterListCtrlTo_p_wxControl(void *x) {
35778     return (void *)((wxControl *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35779 }
35780 static void *_p_wxPyListCtrlTo_p_wxControl(void *x) {
35781     return (void *)((wxControl *)  ((wxPyListCtrl *) x));
35782 }
35783 static void *_p_wxComboBoxTo_p_wxControl(void *x) {
35784     return (void *)((wxControl *) (wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35785 }
35786 static void *_p_wxGenericDirCtrlTo_p_wxControl(void *x) {
35787     return (void *)((wxControl *)  ((wxGenericDirCtrl *) x));
35788 }
35789 static void *_p_wxScrollBarTo_p_wxControl(void *x) {
35790     return (void *)((wxControl *)  ((wxScrollBar *) x));
35791 }
35792 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
35793     return (void *)((wxControl *)  ((wxControlWithItems *) x));
35794 }
35795 static void *_p_wxGaugeTo_p_wxControl(void *x) {
35796     return (void *)((wxControl *)  ((wxGauge *) x));
35797 }
35798 static void *_p_wxStaticLineTo_p_wxControl(void *x) {
35799     return (void *)((wxControl *)  ((wxStaticLine *) x));
35800 }
35801 static void *_p_wxChoicebookTo_p_wxControl(void *x) {
35802     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxChoicebook *) x));
35803 }
35804 static void *_p_wxListbookTo_p_wxControl(void *x) {
35805     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxListbook *) x));
35806 }
35807 static void *_p_wxPyTreeCtrlTo_p_wxControl(void *x) {
35808     return (void *)((wxControl *)  ((wxPyTreeCtrl *) x));
35809 }
35810 static void *_p_wxCheckBoxTo_p_wxControl(void *x) {
35811     return (void *)((wxControl *)  ((wxCheckBox *) x));
35812 }
35813 static void *_p_wxRadioBoxTo_p_wxControl(void *x) {
35814     return (void *)((wxControl *)  ((wxRadioBox *) x));
35815 }
35816 static void *_p_wxChoiceTo_p_wxControl(void *x) {
35817     return (void *)((wxControl *) (wxControlWithItems *) ((wxChoice *) x));
35818 }
35819 static void *_p_wxListBoxTo_p_wxControl(void *x) {
35820     return (void *)((wxControl *) (wxControlWithItems *) ((wxListBox *) x));
35821 }
35822 static void *_p_wxCheckListBoxTo_p_wxControl(void *x) {
35823     return (void *)((wxControl *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
35824 }
35825 static void *_p_wxListViewTo_p_wxControl(void *x) {
35826     return (void *)((wxControl *) (wxPyListCtrl *) ((wxListView *) x));
35827 }
35828 static void *_p_wxNotebookTo_p_wxControl(void *x) {
35829     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxNotebook *) x));
35830 }
35831 static void *_p_wxStaticBitmapTo_p_wxControl(void *x) {
35832     return (void *)((wxControl *)  ((wxStaticBitmap *) x));
35833 }
35834 static void *_p_wxSpinCtrlTo_p_wxControl(void *x) {
35835     return (void *)((wxControl *)  ((wxSpinCtrl *) x));
35836 }
35837 static void *_p_wxStaticTextTo_p_wxControl(void *x) {
35838     return (void *)((wxControl *)  ((wxStaticText *) x));
35839 }
35840 static void *_p_wxStaticBoxTo_p_wxControl(void *x) {
35841     return (void *)((wxControl *)  ((wxStaticBox *) x));
35842 }
35843 static void *_p_wxSliderTo_p_wxControl(void *x) {
35844     return (void *)((wxControl *)  ((wxSlider *) x));
35845 }
35846 static void *_p_wxContextHelpButtonTo_p_wxControl(void *x) {
35847     return (void *)((wxControl *) (wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
35848 }
35849 static void *_p_wxSpinButtonTo_p_wxControl(void *x) {
35850     return (void *)((wxControl *)  ((wxSpinButton *) x));
35851 }
35852 static void *_p_wxButtonTo_p_wxControl(void *x) {
35853     return (void *)((wxControl *)  ((wxButton *) x));
35854 }
35855 static void *_p_wxBitmapButtonTo_p_wxControl(void *x) {
35856     return (void *)((wxControl *) (wxButton *) ((wxBitmapButton *) x));
35857 }
35858 static void *_p_wxTextCtrlTo_p_wxControl(void *x) {
35859     return (void *)((wxControl *)  ((wxTextCtrl *) x));
35860 }
35861 static void *_p_wxToolBarTo_p_wxToolBarBase(void *x) {
35862     return (void *)((wxToolBarBase *)  ((wxToolBar *) x));
35863 }
35864 static void *_p_wxComboBoxTo_p_wxChoice(void *x) {
35865     return (void *)((wxChoice *)  ((wxComboBox *) x));
35866 }
35867 static void *_p_wxDirFilterListCtrlTo_p_wxChoice(void *x) {
35868     return (void *)((wxChoice *)  ((wxDirFilterListCtrl *) x));
35869 }
35870 static void *_p_wxBookCtrlBaseEventTo_p_wxNotifyEvent(void *x) {
35871     return (void *)((wxNotifyEvent *)  ((wxBookCtrlBaseEvent *) x));
35872 }
35873 static void *_p_wxTreeEventTo_p_wxNotifyEvent(void *x) {
35874     return (void *)((wxNotifyEvent *)  ((wxTreeEvent *) x));
35875 }
35876 static void *_p_wxListEventTo_p_wxNotifyEvent(void *x) {
35877     return (void *)((wxNotifyEvent *)  ((wxListEvent *) x));
35878 }
35879 static void *_p_wxSpinEventTo_p_wxNotifyEvent(void *x) {
35880     return (void *)((wxNotifyEvent *)  ((wxSpinEvent *) x));
35881 }
35882 static void *_p_wxNotebookEventTo_p_wxNotifyEvent(void *x) {
35883     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
35884 }
35885 static void *_p_wxListbookEventTo_p_wxNotifyEvent(void *x) {
35886     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
35887 }
35888 static void *_p_wxChoicebookEventTo_p_wxNotifyEvent(void *x) {
35889     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
35890 }
35891 static void *_p_wxChoicebookTo_p_wxBookCtrlBase(void *x) {
35892     return (void *)((wxBookCtrlBase *)  ((wxChoicebook *) x));
35893 }
35894 static void *_p_wxListbookTo_p_wxBookCtrlBase(void *x) {
35895     return (void *)((wxBookCtrlBase *)  ((wxListbook *) x));
35896 }
35897 static void *_p_wxNotebookTo_p_wxBookCtrlBase(void *x) {
35898     return (void *)((wxBookCtrlBase *)  ((wxNotebook *) x));
35899 }
35900 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
35901     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
35902 }
35903 static void *_p_wxBookCtrlBaseTo_p_wxEvtHandler(void *x) {
35904     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
35905 }
35906 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
35907     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
35908 }
35909 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
35910     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
35911 }
35912 static void *_p_wxToolBarTo_p_wxEvtHandler(void *x) {
35913     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
35914 }
35915 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
35916     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
35917 }
35918 static void *_p_wxToggleButtonTo_p_wxEvtHandler(void *x) {
35919     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxToggleButton *) x));
35920 }
35921 static void *_p_wxRadioButtonTo_p_wxEvtHandler(void *x) {
35922     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioButton *) x));
35923 }
35924 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
35925     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
35926 }
35927 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
35928     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
35929 }
35930 static void *_p_wxToolBarBaseTo_p_wxEvtHandler(void *x) {
35931     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxToolBarBase *) x));
35932 }
35933 static void *_p_wxComboBoxTo_p_wxEvtHandler(void *x) {
35934     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35935 }
35936 static void *_p_wxPyListCtrlTo_p_wxEvtHandler(void *x) {
35937     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
35938 }
35939 static void *_p_wxDirFilterListCtrlTo_p_wxEvtHandler(void *x) {
35940     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35941 }
35942 static void *_p_wxPyControlTo_p_wxEvtHandler(void *x) {
35943     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyControl *) x));
35944 }
35945 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
35946     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
35947 }
35948 static void *_p_wxGenericDirCtrlTo_p_wxEvtHandler(void *x) {
35949     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
35950 }
35951 static void *_p_wxScrollBarTo_p_wxEvtHandler(void *x) {
35952     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxScrollBar *) x));
35953 }
35954 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
35955     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
35956 }
35957 static void *_p_wxGaugeTo_p_wxEvtHandler(void *x) {
35958     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGauge *) x));
35959 }
35960 static void *_p_wxStaticLineTo_p_wxEvtHandler(void *x) {
35961     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticLine *) x));
35962 }
35963 static void *_p_wxChoicebookTo_p_wxEvtHandler(void *x) {
35964     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
35965 }
35966 static void *_p_wxListbookTo_p_wxEvtHandler(void *x) {
35967     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
35968 }
35969 static void *_p_wxPyTreeCtrlTo_p_wxEvtHandler(void *x) {
35970     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
35971 }
35972 static void *_p_wxCheckBoxTo_p_wxEvtHandler(void *x) {
35973     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxCheckBox *) x));
35974 }
35975 static void *_p_wxRadioBoxTo_p_wxEvtHandler(void *x) {
35976     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioBox *) x));
35977 }
35978 static void *_p_wxCheckListBoxTo_p_wxEvtHandler(void *x) {
35979     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
35980 }
35981 static void *_p_wxListBoxTo_p_wxEvtHandler(void *x) {
35982     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
35983 }
35984 static void *_p_wxChoiceTo_p_wxEvtHandler(void *x) {
35985     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
35986 }
35987 static void *_p_wxNotebookTo_p_wxEvtHandler(void *x) {
35988     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
35989 }
35990 static void *_p_wxStaticBitmapTo_p_wxEvtHandler(void *x) {
35991     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
35992 }
35993 static void *_p_wxListViewTo_p_wxEvtHandler(void *x) {
35994     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
35995 }
35996 static void *_p_wxSpinCtrlTo_p_wxEvtHandler(void *x) {
35997     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
35998 }
35999 static void *_p_wxStaticTextTo_p_wxEvtHandler(void *x) {
36000     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticText *) x));
36001 }
36002 static void *_p_wxStaticBoxTo_p_wxEvtHandler(void *x) {
36003     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBox *) x));
36004 }
36005 static void *_p_wxSliderTo_p_wxEvtHandler(void *x) {
36006     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSlider *) x));
36007 }
36008 static void *_p_wxSpinButtonTo_p_wxEvtHandler(void *x) {
36009     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinButton *) x));
36010 }
36011 static void *_p_wxButtonTo_p_wxEvtHandler(void *x) {
36012     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxButton *) x));
36013 }
36014 static void *_p_wxBitmapButtonTo_p_wxEvtHandler(void *x) {
36015     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxButton *) ((wxBitmapButton *) x));
36016 }
36017 static void *_p_wxContextHelpButtonTo_p_wxEvtHandler(void *x) {
36018     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36019 }
36020 static void *_p_wxTextCtrlTo_p_wxEvtHandler(void *x) {
36021     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxTextCtrl *) x));
36022 }
36023 static void *_p_wxCheckListBoxTo_p_wxListBox(void *x) {
36024     return (void *)((wxListBox *)  ((wxCheckListBox *) x));
36025 }
36026 static void *_p_wxBitmapButtonTo_p_wxButton(void *x) {
36027     return (void *)((wxButton *)  ((wxBitmapButton *) x));
36028 }
36029 static void *_p_wxContextHelpButtonTo_p_wxButton(void *x) {
36030     return (void *)((wxButton *) (wxBitmapButton *) ((wxContextHelpButton *) x));
36031 }
36032 static void *_p_wxContextHelpButtonTo_p_wxBitmapButton(void *x) {
36033     return (void *)((wxBitmapButton *)  ((wxContextHelpButton *) x));
36034 }
36035 static void *_p_wxSimpleHelpProviderTo_p_wxHelpProvider(void *x) {
36036     return (void *)((wxHelpProvider *)  ((wxSimpleHelpProvider *) x));
36037 }
36038 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36039     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
36040 }
36041 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36042     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36043 }
36044 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36045     return (void *)((wxObject *)  ((wxSizerItem *) x));
36046 }
36047 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36048     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36049 }
36050 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36051     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
36052 }
36053 static void *_p_wxTextUrlEventTo_p_wxObject(void *x) {
36054     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxTextUrlEvent *) x));
36055 }
36056 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36057     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36058 }
36059 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36060     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36061 }
36062 static void *_p_wxSizerTo_p_wxObject(void *x) {
36063     return (void *)((wxObject *)  ((wxSizer *) x));
36064 }
36065 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36066     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36067 }
36068 static void *_p_wxCheckBoxTo_p_wxObject(void *x) {
36069     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxCheckBox *) x));
36070 }
36071 static void *_p_wxPyTreeCtrlTo_p_wxObject(void *x) {
36072     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
36073 }
36074 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36075     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36076 }
36077 static void *_p_wxEventTo_p_wxObject(void *x) {
36078     return (void *)((wxObject *)  ((wxEvent *) x));
36079 }
36080 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36081     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36082 }
36083 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36084     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36085 }
36086 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36087     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36088 }
36089 static void *_p_wxGenericDirCtrlTo_p_wxObject(void *x) {
36090     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
36091 }
36092 static void *_p_wxPyListCtrlTo_p_wxObject(void *x) {
36093     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
36094 }
36095 static void *_p_wxDirFilterListCtrlTo_p_wxObject(void *x) {
36096     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
36097 }
36098 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36099     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36100 }
36101 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36102     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36103 }
36104 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36105     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36106 }
36107 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36108     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36109 }
36110 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36111     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36112 }
36113 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36114     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36115 }
36116 static void *_p_wxStaticLineTo_p_wxObject(void *x) {
36117     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticLine *) x));
36118 }
36119 static void *_p_wxControlTo_p_wxObject(void *x) {
36120     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36121 }
36122 static void *_p_wxPyControlTo_p_wxObject(void *x) {
36123     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyControl *) x));
36124 }
36125 static void *_p_wxGaugeTo_p_wxObject(void *x) {
36126     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGauge *) x));
36127 }
36128 static void *_p_wxRadioButtonTo_p_wxObject(void *x) {
36129     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioButton *) x));
36130 }
36131 static void *_p_wxToggleButtonTo_p_wxObject(void *x) {
36132     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxToggleButton *) x));
36133 }
36134 static void *_p_wxToolBarBaseTo_p_wxObject(void *x) {
36135     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxToolBarBase *) x));
36136 }
36137 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36138     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36139 }
36140 static void *_p_wxChoiceTo_p_wxObject(void *x) {
36141     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
36142 }
36143 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36144     return (void *)((wxObject *)  ((wxFSFile *) x));
36145 }
36146 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36147     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36148 }
36149 static void *_p_wxListViewTo_p_wxObject(void *x) {
36150     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
36151 }
36152 static void *_p_wxTextCtrlTo_p_wxObject(void *x) {
36153     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxTextCtrl *) x));
36154 }
36155 static void *_p_wxNotebookTo_p_wxObject(void *x) {
36156     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
36157 }
36158 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36159     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36160 }
36161 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36162     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
36163 }
36164 static void *_p_wxChoicebookTo_p_wxObject(void *x) {
36165     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
36166 }
36167 static void *_p_wxListbookTo_p_wxObject(void *x) {
36168     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
36169 }
36170 static void *_p_wxShowEventTo_p_wxObject(void *x) {
36171     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
36172 }
36173 static void *_p_wxStaticBitmapTo_p_wxObject(void *x) {
36174     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
36175 }
36176 static void *_p_wxSliderTo_p_wxObject(void *x) {
36177     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSlider *) x));
36178 }
36179 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
36180     return (void *)((wxObject *)  ((wxMenuItem *) x));
36181 }
36182 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
36183     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
36184 }
36185 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
36186     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
36187 }
36188 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
36189     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
36190 }
36191 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
36192     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
36193 }
36194 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
36195     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
36196 }
36197 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
36198     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
36199 }
36200 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
36201     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
36202 }
36203 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
36204     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
36205 }
36206 static void *_p_wxStaticBoxTo_p_wxObject(void *x) {
36207     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBox *) x));
36208 }
36209 static void *_p_wxContextHelpTo_p_wxObject(void *x) {
36210     return (void *)((wxObject *)  ((wxContextHelp *) x));
36211 }
36212 static void *_p_wxBookCtrlBaseTo_p_wxObject(void *x) {
36213     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
36214 }
36215 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
36216     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
36217 }
36218 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
36219     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
36220 }
36221 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
36222     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
36223 }
36224 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
36225     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
36226 }
36227 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
36228     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
36229 }
36230 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
36231     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
36232 }
36233 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
36234     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
36235 }
36236 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
36237     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
36238 }
36239 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
36240     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
36241 }
36242 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
36243     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
36244 }
36245 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
36246     return (void *)((wxObject *)  ((wxImageHandler *) x));
36247 }
36248 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
36249     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
36250 }
36251 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
36252     return (void *)((wxObject *)  ((wxEvtHandler *) x));
36253 }
36254 static void *_p_wxListEventTo_p_wxObject(void *x) {
36255     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
36256 }
36257 static void *_p_wxListBoxTo_p_wxObject(void *x) {
36258     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
36259 }
36260 static void *_p_wxCheckListBoxTo_p_wxObject(void *x) {
36261     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
36262 }
36263 static void *_p_wxButtonTo_p_wxObject(void *x) {
36264     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxButton *) x));
36265 }
36266 static void *_p_wxBitmapButtonTo_p_wxObject(void *x) {
36267     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxButton *) ((wxBitmapButton *) x));
36268 }
36269 static void *_p_wxSpinButtonTo_p_wxObject(void *x) {
36270     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinButton *) x));
36271 }
36272 static void *_p_wxContextHelpButtonTo_p_wxObject(void *x) {
36273     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36274 }
36275 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
36276     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
36277 }
36278 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
36279     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
36280 }
36281 static void *_p_wxScrollBarTo_p_wxObject(void *x) {
36282     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxScrollBar *) x));
36283 }
36284 static void *_p_wxRadioBoxTo_p_wxObject(void *x) {
36285     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioBox *) x));
36286 }
36287 static void *_p_wxComboBoxTo_p_wxObject(void *x) {
36288     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
36289 }
36290 static void *_p_wxHelpEventTo_p_wxObject(void *x) {
36291     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxHelpEvent *) x));
36292 }
36293 static void *_p_wxListItemTo_p_wxObject(void *x) {
36294     return (void *)((wxObject *)  ((wxListItem *) x));
36295 }
36296 static void *_p_wxImageTo_p_wxObject(void *x) {
36297     return (void *)((wxObject *)  ((wxImage *) x));
36298 }
36299 static void *_p_wxNotebookSizerTo_p_wxObject(void *x) {
36300     return (void *)((wxObject *) (wxSizer *) ((wxNotebookSizer *) x));
36301 }
36302 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
36303     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
36304 }
36305 static void *_p_wxSpinEventTo_p_wxObject(void *x) {
36306     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
36307 }
36308 static void *_p_wxGenericDragImageTo_p_wxObject(void *x) {
36309     return (void *)((wxObject *)  ((wxGenericDragImage *) x));
36310 }
36311 static void *_p_wxSpinCtrlTo_p_wxObject(void *x) {
36312     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
36313 }
36314 static void *_p_wxNotebookEventTo_p_wxObject(void *x) {
36315     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
36316 }
36317 static void *_p_wxListbookEventTo_p_wxObject(void *x) {
36318     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
36319 }
36320 static void *_p_wxChoicebookEventTo_p_wxObject(void *x) {
36321     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
36322 }
36323 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
36324     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36325 }
36326 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
36327     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
36328 }
36329 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
36330     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
36331 }
36332 static void *_p_wxWindowTo_p_wxObject(void *x) {
36333     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
36334 }
36335 static void *_p_wxMenuTo_p_wxObject(void *x) {
36336     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
36337 }
36338 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
36339     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
36340 }
36341 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
36342     return (void *)((wxObject *)  ((wxFileSystem *) x));
36343 }
36344 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
36345     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
36346 }
36347 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
36348     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
36349 }
36350 static void *_p_wxPyAppTo_p_wxObject(void *x) {
36351     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
36352 }
36353 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
36354     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
36355 }
36356 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
36357     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
36358 }
36359 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
36360     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
36361 }
36362 static void *_p_wxBookCtrlBaseEventTo_p_wxObject(void *x) {
36363     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
36364 }
36365 static void *_p_wxTreeEventTo_p_wxObject(void *x) {
36366     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
36367 }
36368 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
36369     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
36370 }
36371 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
36372     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
36373 }
36374 static void *_p_wxStaticTextTo_p_wxObject(void *x) {
36375     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticText *) x));
36376 }
36377 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
36378     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
36379 }
36380 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
36381     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
36382 }
36383 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
36384     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
36385 }
36386 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
36387     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36388 }
36389 static void *_p_wxToolBarToolBaseTo_p_wxObject(void *x) {
36390     return (void *)((wxObject *)  ((wxToolBarToolBase *) x));
36391 }
36392 static void *_p_wxToolBarTo_p_wxObject(void *x) {
36393     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
36394 }
36395 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
36396     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
36397 }
36398 static void *_p_wxValidatorTo_p_wxObject(void *x) {
36399     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
36400 }
36401 static void *_p_wxBookCtrlSizerTo_p_wxObject(void *x) {
36402     return (void *)((wxObject *) (wxSizer *) ((wxBookCtrlSizer *) x));
36403 }
36404 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
36405     return (void *)((wxWindow *)  ((wxMenuBar *) x));
36406 }
36407 static void *_p_wxBookCtrlBaseTo_p_wxWindow(void *x) {
36408     return (void *)((wxWindow *) (wxControl *) ((wxBookCtrlBase *) x));
36409 }
36410 static void *_p_wxToolBarTo_p_wxWindow(void *x) {
36411     return (void *)((wxWindow *) (wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
36412 }
36413 static void *_p_wxToggleButtonTo_p_wxWindow(void *x) {
36414     return (void *)((wxWindow *) (wxControl *) ((wxToggleButton *) x));
36415 }
36416 static void *_p_wxRadioButtonTo_p_wxWindow(void *x) {
36417     return (void *)((wxWindow *) (wxControl *) ((wxRadioButton *) x));
36418 }
36419 static void *_p_wxControlTo_p_wxWindow(void *x) {
36420     return (void *)((wxWindow *)  ((wxControl *) x));
36421 }
36422 static void *_p_wxToolBarBaseTo_p_wxWindow(void *x) {
36423     return (void *)((wxWindow *) (wxControl *) ((wxToolBarBase *) x));
36424 }
36425 static void *_p_wxDirFilterListCtrlTo_p_wxWindow(void *x) {
36426     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
36427 }
36428 static void *_p_wxPyListCtrlTo_p_wxWindow(void *x) {
36429     return (void *)((wxWindow *) (wxControl *) ((wxPyListCtrl *) x));
36430 }
36431 static void *_p_wxComboBoxTo_p_wxWindow(void *x) {
36432     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
36433 }
36434 static void *_p_wxPyControlTo_p_wxWindow(void *x) {
36435     return (void *)((wxWindow *) (wxControl *) ((wxPyControl *) x));
36436 }
36437 static void *_p_wxGenericDirCtrlTo_p_wxWindow(void *x) {
36438     return (void *)((wxWindow *) (wxControl *) ((wxGenericDirCtrl *) x));
36439 }
36440 static void *_p_wxScrollBarTo_p_wxWindow(void *x) {
36441     return (void *)((wxWindow *) (wxControl *) ((wxScrollBar *) x));
36442 }
36443 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
36444     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
36445 }
36446 static void *_p_wxGaugeTo_p_wxWindow(void *x) {
36447     return (void *)((wxWindow *) (wxControl *) ((wxGauge *) x));
36448 }
36449 static void *_p_wxStaticLineTo_p_wxWindow(void *x) {
36450     return (void *)((wxWindow *) (wxControl *) ((wxStaticLine *) x));
36451 }
36452 static void *_p_wxChoicebookTo_p_wxWindow(void *x) {
36453     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
36454 }
36455 static void *_p_wxListbookTo_p_wxWindow(void *x) {
36456     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
36457 }
36458 static void *_p_wxPyTreeCtrlTo_p_wxWindow(void *x) {
36459     return (void *)((wxWindow *) (wxControl *) ((wxPyTreeCtrl *) x));
36460 }
36461 static void *_p_wxCheckBoxTo_p_wxWindow(void *x) {
36462     return (void *)((wxWindow *) (wxControl *) ((wxCheckBox *) x));
36463 }
36464 static void *_p_wxRadioBoxTo_p_wxWindow(void *x) {
36465     return (void *)((wxWindow *) (wxControl *) ((wxRadioBox *) x));
36466 }
36467 static void *_p_wxCheckListBoxTo_p_wxWindow(void *x) {
36468     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
36469 }
36470 static void *_p_wxChoiceTo_p_wxWindow(void *x) {
36471     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxChoice *) x));
36472 }
36473 static void *_p_wxListBoxTo_p_wxWindow(void *x) {
36474     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxListBox *) x));
36475 }
36476 static void *_p_wxListViewTo_p_wxWindow(void *x) {
36477     return (void *)((wxWindow *) (wxControl *)(wxPyListCtrl *) ((wxListView *) x));
36478 }
36479 static void *_p_wxNotebookTo_p_wxWindow(void *x) {
36480     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
36481 }
36482 static void *_p_wxStaticBitmapTo_p_wxWindow(void *x) {
36483     return (void *)((wxWindow *) (wxControl *) ((wxStaticBitmap *) x));
36484 }
36485 static void *_p_wxSpinCtrlTo_p_wxWindow(void *x) {
36486     return (void *)((wxWindow *) (wxControl *) ((wxSpinCtrl *) x));
36487 }
36488 static void *_p_wxStaticTextTo_p_wxWindow(void *x) {
36489     return (void *)((wxWindow *) (wxControl *) ((wxStaticText *) x));
36490 }
36491 static void *_p_wxStaticBoxTo_p_wxWindow(void *x) {
36492     return (void *)((wxWindow *) (wxControl *) ((wxStaticBox *) x));
36493 }
36494 static void *_p_wxSliderTo_p_wxWindow(void *x) {
36495     return (void *)((wxWindow *) (wxControl *) ((wxSlider *) x));
36496 }
36497 static void *_p_wxSpinButtonTo_p_wxWindow(void *x) {
36498     return (void *)((wxWindow *) (wxControl *) ((wxSpinButton *) x));
36499 }
36500 static void *_p_wxButtonTo_p_wxWindow(void *x) {
36501     return (void *)((wxWindow *) (wxControl *) ((wxButton *) x));
36502 }
36503 static void *_p_wxBitmapButtonTo_p_wxWindow(void *x) {
36504     return (void *)((wxWindow *) (wxControl *)(wxButton *) ((wxBitmapButton *) x));
36505 }
36506 static void *_p_wxContextHelpButtonTo_p_wxWindow(void *x) {
36507     return (void *)((wxWindow *) (wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36508 }
36509 static void *_p_wxTextCtrlTo_p_wxWindow(void *x) {
36510     return (void *)((wxWindow *) (wxControl *) ((wxTextCtrl *) x));
36511 }
36512 static void *_p_wxNotebookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36513     return (void *)((wxBookCtrlBaseEvent *)  ((wxNotebookEvent *) x));
36514 }
36515 static void *_p_wxListbookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36516     return (void *)((wxBookCtrlBaseEvent *)  ((wxListbookEvent *) x));
36517 }
36518 static void *_p_wxChoicebookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36519     return (void *)((wxBookCtrlBaseEvent *)  ((wxChoicebookEvent *) x));
36520 }
36521 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
36522     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
36523 }
36524 static void *_p_wxTextUrlEventTo_p_wxCommandEvent(void *x) {
36525     return (void *)((wxCommandEvent *)  ((wxTextUrlEvent *) x));
36526 }
36527 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
36528     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
36529 }
36530 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
36531     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
36532 }
36533 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
36534     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
36535 }
36536 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
36537     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
36538 }
36539 static void *_p_wxChoicebookEventTo_p_wxCommandEvent(void *x) {
36540     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
36541 }
36542 static void *_p_wxListbookEventTo_p_wxCommandEvent(void *x) {
36543     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
36544 }
36545 static void *_p_wxNotebookEventTo_p_wxCommandEvent(void *x) {
36546     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
36547 }
36548 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
36549     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
36550 }
36551 static void *_p_wxListEventTo_p_wxCommandEvent(void *x) {
36552     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxListEvent *) x));
36553 }
36554 static void *_p_wxBookCtrlBaseEventTo_p_wxCommandEvent(void *x) {
36555     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
36556 }
36557 static void *_p_wxTreeEventTo_p_wxCommandEvent(void *x) {
36558     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxTreeEvent *) x));
36559 }
36560 static void *_p_wxSpinEventTo_p_wxCommandEvent(void *x) {
36561     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSpinEvent *) x));
36562 }
36563 static void *_p_wxHelpEventTo_p_wxCommandEvent(void *x) {
36564     return (void *)((wxCommandEvent *)  ((wxHelpEvent *) x));
36565 }
36566 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
36567     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
36568 }
36569 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
36570     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
36571 }
36572 static void *_p_wxComboBoxTo_p_wxControlWithItems(void *x) {
36573     return (void *)((wxControlWithItems *) (wxChoice *) ((wxComboBox *) x));
36574 }
36575 static void *_p_wxDirFilterListCtrlTo_p_wxControlWithItems(void *x) {
36576     return (void *)((wxControlWithItems *) (wxChoice *) ((wxDirFilterListCtrl *) x));
36577 }
36578 static void *_p_wxChoiceTo_p_wxControlWithItems(void *x) {
36579     return (void *)((wxControlWithItems *)  ((wxChoice *) x));
36580 }
36581 static void *_p_wxListBoxTo_p_wxControlWithItems(void *x) {
36582     return (void *)((wxControlWithItems *)  ((wxListBox *) x));
36583 }
36584 static void *_p_wxCheckListBoxTo_p_wxControlWithItems(void *x) {
36585     return (void *)((wxControlWithItems *) (wxListBox *) ((wxCheckListBox *) x));
36586 }
36587 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
36588     return (void *)((wxValidator *)  ((wxPyValidator *) x));
36589 }
36590 static swig_type_info _swigt__p_wxTextUrlEvent[] = {{"_p_wxTextUrlEvent", 0, "wxTextUrlEvent *", 0, 0, 0, 0},{"_p_wxTextUrlEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36591 static swig_type_info _swigt__p_wxSizer[] = {{"_p_wxSizer", 0, "wxSizer *", 0, 0, 0, 0},{"_p_wxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxNotebookSizer", _p_wxNotebookSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxBookCtrlSizer", _p_wxBookCtrlSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36592 static swig_type_info _swigt__p_wxCheckBox[] = {{"_p_wxCheckBox", 0, "wxCheckBox *", 0, 0, 0, 0},{"_p_wxCheckBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36593 static swig_type_info _swigt__p_wxPyTreeCtrl[] = {{"_p_wxPyTreeCtrl", 0, "wxPyTreeCtrl *", 0, 0, 0, 0},{"_p_wxPyTreeCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36594 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBaseEvent", _p_wxBookCtrlBaseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTreeEvent", _p_wxTreeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTextUrlEvent", _p_wxTextUrlEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxListEvent", _p_wxListEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxHelpEvent", _p_wxHelpEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotebookEvent", _p_wxNotebookEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxListbookEvent", _p_wxListbookEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChoicebookEvent", _p_wxChoicebookEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSpinEvent", _p_wxSpinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36595 static swig_type_info _swigt__p_wxGenericDirCtrl[] = {{"_p_wxGenericDirCtrl", 0, "wxGenericDirCtrl *", 0, 0, 0, 0},{"_p_wxGenericDirCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36596 static swig_type_info _swigt__p_bool[] = {{"_p_bool", 0, "bool *", 0, 0, 0, 0},{"_p_bool", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36597 static swig_type_info _swigt__p_wxItemContainer[] = {{"_p_wxItemContainer", 0, "wxItemContainer *", 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxItemContainer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36598 static swig_type_info _swigt__p_wxPyListCtrl[] = {{"_p_wxPyListCtrl", 0, "wxPyListCtrl *", 0, 0, 0, 0},{"_p_wxPyListCtrl", 0, 0, 0, 0, 0, 0},{"_p_wxListView", _p_wxListViewTo_p_wxPyListCtrl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36599 static swig_type_info _swigt__p_wxPyTreeItemData[] = {{"_p_wxPyTreeItemData", 0, "wxPyTreeItemData *", 0, 0, 0, 0},{"_p_wxPyTreeItemData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36600 static swig_type_info _swigt__p_wxDirFilterListCtrl[] = {{"_p_wxDirFilterListCtrl", 0, "wxDirFilterListCtrl *", 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36601 static swig_type_info _swigt__p_wxStaticLine[] = {{"_p_wxStaticLine", 0, "wxStaticLine *", 0, 0, 0, 0},{"_p_wxStaticLine", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36602 static swig_type_info _swigt__p_wxControl[] = {{"_p_wxControl", 0, "wxControl *", 0, 0, 0, 0},{"_p_wxBookCtrlBase", _p_wxBookCtrlBaseTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxToolBar", _p_wxToolBarTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxToggleButton", _p_wxToggleButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxRadioButton", _p_wxRadioButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxControl", 0, 0, 0, 0, 0, 0},{"_p_wxPyControl", _p_wxPyControlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxToolBarBase", _p_wxToolBarBaseTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxPyListCtrl", _p_wxPyListCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxGenericDirCtrl", _p_wxGenericDirCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxScrollBar", _p_wxScrollBarTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxGauge", _p_wxGaugeTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxStaticLine", _p_wxStaticLineTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxChoicebook", _p_wxChoicebookTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxListbook", _p_wxListbookTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxPyTreeCtrl", _p_wxPyTreeCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxCheckBox", _p_wxCheckBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxRadioBox", _p_wxRadioBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxListView", _p_wxListViewTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxNotebook", _p_wxNotebookTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxStaticBitmap", _p_wxStaticBitmapTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxSpinCtrl", _p_wxSpinCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxStaticText", _p_wxStaticTextTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxStaticBox", _p_wxStaticBoxTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxSlider", _p_wxSliderTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxSpinButton", _p_wxSpinButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxButton", _p_wxButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxBitmapButton", _p_wxBitmapButtonTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxTextCtrl", _p_wxTextCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36603 static swig_type_info _swigt__p_wxPyControl[] = {{"_p_wxPyControl", 0, "wxPyControl *", 0, 0, 0, 0},{"_p_wxPyControl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36604 static swig_type_info _swigt__p_wxGauge[] = {{"_p_wxGauge", 0, "wxGauge *", 0, 0, 0, 0},{"_p_wxGauge", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36605 static swig_type_info _swigt__p_wxToolBarBase[] = {{"_p_wxToolBarBase", 0, "wxToolBarBase *", 0, 0, 0, 0},{"_p_wxToolBarBase", 0, 0, 0, 0, 0, 0},{"_p_wxToolBar", _p_wxToolBarTo_p_wxToolBarBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36606 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}};
36607 static swig_type_info _swigt__p_wxToggleButton[] = {{"_p_wxToggleButton", 0, "wxToggleButton *", 0, 0, 0, 0},{"_p_wxToggleButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36608 static swig_type_info _swigt__p_wxRadioButton[] = {{"_p_wxRadioButton", 0, "wxRadioButton *", 0, 0, 0, 0},{"_p_wxRadioButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36609 static swig_type_info _swigt__p_wxChoice[] = {{"_p_wxChoice", 0, "wxChoice *", 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxChoice, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxChoice, 0, 0, 0, 0, 0},{"_p_wxChoice", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36610 static swig_type_info _swigt__p_wxMemoryDC[] = {{"_p_wxMemoryDC", 0, "wxMemoryDC *", 0, 0, 0, 0},{"_p_wxMemoryDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36611 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}};
36612 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}};
36613 static swig_type_info _swigt__p_wxListItemAttr[] = {{"_p_wxListItemAttr", 0, "wxListItemAttr *", 0, 0, 0, 0},{"_p_wxListItemAttr", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36614 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36615 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}};
36616 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}};
36617 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36618 static swig_type_info _swigt__p_wxListView[] = {{"_p_wxListView", 0, "wxListView *", 0, 0, 0, 0},{"_p_wxListView", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36619 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}};
36620 static swig_type_info _swigt__p_wxVisualAttributes[] = {{"_p_wxVisualAttributes", 0, "wxVisualAttributes *", 0, 0, 0, 0},{"_p_wxVisualAttributes", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36621 static swig_type_info _swigt__p_wxTextCtrl[] = {{"_p_wxTextCtrl", 0, "wxTextCtrl *", 0, 0, 0, 0},{"_p_wxTextCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36622 static swig_type_info _swigt__p_wxNotebook[] = {{"_p_wxNotebook", 0, "wxNotebook *", 0, 0, 0, 0},{"_p_wxNotebook", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36623 static swig_type_info _swigt__p_wxChoicebook[] = {{"_p_wxChoicebook", 0, "wxChoicebook *", 0, 0, 0, 0},{"_p_wxChoicebook", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36624 static swig_type_info _swigt__p_wxNotifyEvent[] = {{"_p_wxNotifyEvent", 0, "wxNotifyEvent *", 0, 0, 0, 0},{"_p_wxBookCtrlBaseEvent", _p_wxBookCtrlBaseEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxTreeEvent", _p_wxTreeEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxListEvent", _p_wxListEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxSpinEvent", _p_wxSpinEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxNotebookEvent", _p_wxNotebookEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxListbookEvent", _p_wxListbookEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxChoicebookEvent", _p_wxChoicebookEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36625 static swig_type_info _swigt__p_wxArrayString[] = {{"_p_wxArrayString", 0, "wxArrayString *", 0, 0, 0, 0},{"_p_wxArrayString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36626 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}};
36627 static swig_type_info _swigt__p_wxListbook[] = {{"_p_wxListbook", 0, "wxListbook *", 0, 0, 0, 0},{"_p_wxListbook", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36628 static swig_type_info _swigt__p_wxStaticBitmap[] = {{"_p_wxStaticBitmap", 0, "wxStaticBitmap *", 0, 0, 0, 0},{"_p_wxStaticBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36629 static swig_type_info _swigt__p_wxSlider[] = {{"_p_wxSlider", 0, "wxSlider *", 0, 0, 0, 0},{"_p_wxSlider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36630 static swig_type_info _swigt__p_wxStaticBox[] = {{"_p_wxStaticBox", 0, "wxStaticBox *", 0, 0, 0, 0},{"_p_wxStaticBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36631 static swig_type_info _swigt__p_wxArrayInt[] = {{"_p_wxArrayInt", 0, "wxArrayInt *", 0, 0, 0, 0},{"_p_wxArrayInt", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36632 static swig_type_info _swigt__p_wxContextHelp[] = {{"_p_wxContextHelp", 0, "wxContextHelp *", 0, 0, 0, 0},{"_p_wxContextHelp", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36633 static swig_type_info _swigt__p_long[] = {{"_p_long", 0, "long *", 0, 0, 0, 0},{"_p_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36634 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}};
36635 static swig_type_info _swigt__p_wxBookCtrlBase[] = {{"_p_wxBookCtrlBase", 0, "wxBookCtrlBase *", 0, 0, 0, 0},{"_p_wxChoicebook", _p_wxChoicebookTo_p_wxBookCtrlBase, 0, 0, 0, 0, 0},{"_p_wxListbook", _p_wxListbookTo_p_wxBookCtrlBase, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBase", 0, 0, 0, 0, 0, 0},{"_p_wxNotebook", _p_wxNotebookTo_p_wxBookCtrlBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36636 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBase", _p_wxBookCtrlBaseTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxToolBar", _p_wxToolBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxToggleButton", _p_wxToggleButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxRadioButton", _p_wxRadioButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyControl", _p_wxPyControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxToolBarBase", _p_wxToolBarBaseTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyListCtrl", _p_wxPyListCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxGenericDirCtrl", _p_wxGenericDirCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxScrollBar", _p_wxScrollBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxGauge", _p_wxGaugeTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStaticLine", _p_wxStaticLineTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxChoicebook", _p_wxChoicebookTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxListbook", _p_wxListbookTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyTreeCtrl", _p_wxPyTreeCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxCheckBox", _p_wxCheckBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxRadioBox", _p_wxRadioBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxListView", _p_wxListViewTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxNotebook", _p_wxNotebookTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStaticBitmap", _p_wxStaticBitmapTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSpinCtrl", _p_wxSpinCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStaticText", _p_wxStaticTextTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStaticBox", _p_wxStaticBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSlider", _p_wxSliderTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxBitmapButton", _p_wxBitmapButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxButton", _p_wxButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSpinButton", _p_wxSpinButtonTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTextCtrl", _p_wxTextCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36637 static swig_type_info _swigt__p_wxListEvent[] = {{"_p_wxListEvent", 0, "wxListEvent *", 0, 0, 0, 0},{"_p_wxListEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36638 static swig_type_info _swigt__p_wxCheckListBox[] = {{"_p_wxCheckListBox", 0, "wxCheckListBox *", 0, 0, 0, 0},{"_p_wxCheckListBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36639 static swig_type_info _swigt__p_wxListBox[] = {{"_p_wxListBox", 0, "wxListBox *", 0, 0, 0, 0},{"_p_wxListBox", 0, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxListBox, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36640 static swig_type_info _swigt__p_wxSpinButton[] = {{"_p_wxSpinButton", 0, "wxSpinButton *", 0, 0, 0, 0},{"_p_wxSpinButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36641 static swig_type_info _swigt__p_wxButton[] = {{"_p_wxButton", 0, "wxButton *", 0, 0, 0, 0},{"_p_wxButton", 0, 0, 0, 0, 0, 0},{"_p_wxBitmapButton", _p_wxBitmapButtonTo_p_wxButton, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxButton, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36642 static swig_type_info _swigt__p_wxBitmapButton[] = {{"_p_wxBitmapButton", 0, "wxBitmapButton *", 0, 0, 0, 0},{"_p_wxBitmapButton", 0, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxBitmapButton, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36643 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}};
36644 static swig_type_info _swigt__p_wxContextHelpButton[] = {{"_p_wxContextHelpButton", 0, "wxContextHelpButton *", 0, 0, 0, 0},{"_p_wxContextHelpButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36645 static swig_type_info _swigt__p_wxRadioBox[] = {{"_p_wxRadioBox", 0, "wxRadioBox *", 0, 0, 0, 0},{"_p_wxRadioBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36646 static swig_type_info _swigt__p_wxScrollBar[] = {{"_p_wxScrollBar", 0, "wxScrollBar *", 0, 0, 0, 0},{"_p_wxScrollBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36647 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}};
36648 static swig_type_info _swigt__p_wxComboBox[] = {{"_p_wxComboBox", 0, "wxComboBox *", 0, 0, 0, 0},{"_p_wxComboBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36649 static swig_type_info _swigt__p_wxTreeItemId[] = {{"_p_wxTreeItemId", 0, "wxTreeItemId *", 0, 0, 0, 0},{"_p_wxTreeItemId", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36650 static swig_type_info _swigt__p_wxHelpEvent[] = {{"_p_wxHelpEvent", 0, "wxHelpEvent *", 0, 0, 0, 0},{"_p_wxHelpEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36651 static swig_type_info _swigt__p_wxListItem[] = {{"_p_wxListItem", 0, "wxListItem *", 0, 0, 0, 0},{"_p_wxListItem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36652 static swig_type_info _swigt__p_wxNotebookSizer[] = {{"_p_wxNotebookSizer", 0, "wxNotebookSizer *", 0, 0, 0, 0},{"_p_wxNotebookSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36653 static swig_type_info _swigt__p_wxSpinEvent[] = {{"_p_wxSpinEvent", 0, "wxSpinEvent *", 0, 0, 0, 0},{"_p_wxSpinEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36654 static swig_type_info _swigt__p_wxGenericDragImage[] = {{"_p_wxGenericDragImage", 0, "wxGenericDragImage *", 0, 0, 0, 0},{"_p_wxGenericDragImage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36655 static swig_type_info _swigt__p_wxSpinCtrl[] = {{"_p_wxSpinCtrl", 0, "wxSpinCtrl *", 0, 0, 0, 0},{"_p_wxSpinCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36656 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}};
36657 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}};
36658 static swig_type_info _swigt__p_wxHelpProvider[] = {{"_p_wxHelpProvider", 0, "wxHelpProvider *", 0, 0, 0, 0},{"_p_wxHelpProvider", 0, 0, 0, 0, 0, 0},{"_p_wxSimpleHelpProvider", _p_wxSimpleHelpProviderTo_p_wxHelpProvider, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36659 static swig_type_info _swigt__p_wxTextAttr[] = {{"_p_wxTextAttr", 0, "wxTextAttr *", 0, 0, 0, 0},{"_p_wxTextAttr", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36660 static swig_type_info _swigt__p_wxSimpleHelpProvider[] = {{"_p_wxSimpleHelpProvider", 0, "wxSimpleHelpProvider *", 0, 0, 0, 0},{"_p_wxSimpleHelpProvider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36661 static swig_type_info _swigt__p_wxChoicebookEvent[] = {{"_p_wxChoicebookEvent", 0, "wxChoicebookEvent *", 0, 0, 0, 0},{"_p_wxChoicebookEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36662 static swig_type_info _swigt__p_wxListbookEvent[] = {{"_p_wxListbookEvent", 0, "wxListbookEvent *", 0, 0, 0, 0},{"_p_wxListbookEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36663 static swig_type_info _swigt__p_wxNotebookEvent[] = {{"_p_wxNotebookEvent", 0, "wxNotebookEvent *", 0, 0, 0, 0},{"_p_wxNotebookEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36664 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}};
36665 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_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_wxTextUrlEvent", _p_wxTextUrlEventTo_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_wxCheckBox", _p_wxCheckBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTreeCtrl", _p_wxPyTreeCtrlTo_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_wxGenericDirCtrl", _p_wxGenericDirCtrlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyListCtrl", _p_wxPyListCtrlTo_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_wxStaticLine", _p_wxStaticLineTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyControl", _p_wxPyControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToggleButton", _p_wxToggleButtonTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRadioButton", _p_wxRadioButtonTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolBarBase", _p_wxToolBarBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGauge", _p_wxGaugeTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListView", _p_wxListViewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotebook", _p_wxNotebookTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTextCtrl", _p_wxTextCtrlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChoicebook", _p_wxChoicebookTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListbook", _p_wxListbookTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBitmap", _p_wxStaticBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSlider", _p_wxSliderTo_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_wxActivateEvent", _p_wxActivateEventTo_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_wxStaticBox", _p_wxStaticBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextHelp", _p_wxContextHelpTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBase", _p_wxBookCtrlBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListEvent", _p_wxListEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmapButton", _p_wxBitmapButtonTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxButton", _p_wxButtonTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSpinButton", _p_wxSpinButtonTo_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_wxScrollBar", _p_wxScrollBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRadioBox", _p_wxRadioBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxHelpEvent", _p_wxHelpEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListItem", _p_wxListItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotebookSizer", _p_wxNotebookSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSpinEvent", _p_wxSpinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGenericDragImage", _p_wxGenericDragImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSpinCtrl", _p_wxSpinCtrlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotebookEvent", _p_wxNotebookEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxListbookEvent", _p_wxListbookEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChoicebookEvent", _p_wxChoicebookEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_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_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_wxBookCtrlBaseEvent", _p_wxBookCtrlBaseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTreeEvent", _p_wxTreeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_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_wxStaticText", _p_wxStaticTextTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolBarToolBase", _p_wxToolBarToolBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolBar", _p_wxToolBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBookCtrlSizer", _p_wxBookCtrlSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36666 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}};
36667 static swig_type_info _swigt__p_wxKeyEvent[] = {{"_p_wxKeyEvent", 0, "wxKeyEvent *", 0, 0, 0, 0},{"_p_wxKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36668 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}};
36669 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBase", _p_wxBookCtrlBaseTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxToolBar", _p_wxToolBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxToggleButton", _p_wxToggleButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxRadioButton", _p_wxRadioButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyControl", _p_wxPyControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxToolBarBase", _p_wxToolBarBaseTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyListCtrl", _p_wxPyListCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxGenericDirCtrl", _p_wxGenericDirCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxScrollBar", _p_wxScrollBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxGauge", _p_wxGaugeTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStaticLine", _p_wxStaticLineTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxChoicebook", _p_wxChoicebookTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxListbook", _p_wxListbookTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyTreeCtrl", _p_wxPyTreeCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxCheckBox", _p_wxCheckBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxRadioBox", _p_wxRadioBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxListView", _p_wxListViewTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxNotebook", _p_wxNotebookTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStaticBitmap", _p_wxStaticBitmapTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSpinCtrl", _p_wxSpinCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStaticText", _p_wxStaticTextTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStaticBox", _p_wxStaticBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSlider", _p_wxSliderTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxContextHelpButton", _p_wxContextHelpButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxBitmapButton", _p_wxBitmapButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxButton", _p_wxButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSpinButton", _p_wxSpinButtonTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTextCtrl", _p_wxTextCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36670 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}};
36671 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}};
36672 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}};
36673 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}};
36674 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}};
36675 static swig_type_info _swigt__p_wxMouseEvent[] = {{"_p_wxMouseEvent", 0, "wxMouseEvent *", 0, 0, 0, 0},{"_p_wxMouseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36676 static swig_type_info _swigt__p_wxBookCtrlBaseEvent[] = {{"_p_wxBookCtrlBaseEvent", 0, "wxBookCtrlBaseEvent *", 0, 0, 0, 0},{"_p_wxBookCtrlBaseEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotebookEvent", _p_wxNotebookEventTo_p_wxBookCtrlBaseEvent, 0, 0, 0, 0, 0},{"_p_wxListbookEvent", _p_wxListbookEventTo_p_wxBookCtrlBaseEvent, 0, 0, 0, 0, 0},{"_p_wxChoicebookEvent", _p_wxChoicebookEventTo_p_wxBookCtrlBaseEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36677 static swig_type_info _swigt__p_wxTreeEvent[] = {{"_p_wxTreeEvent", 0, "wxTreeEvent *", 0, 0, 0, 0},{"_p_wxTreeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36678 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxTextUrlEvent", _p_wxTextUrlEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxChoicebookEvent", _p_wxChoicebookEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxListbookEvent", _p_wxListbookEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxNotebookEvent", _p_wxNotebookEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxListEvent", _p_wxListEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxBookCtrlBaseEvent", _p_wxBookCtrlBaseEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxTreeEvent", _p_wxTreeEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxSpinEvent", _p_wxSpinEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxHelpEvent", _p_wxHelpEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36679 static swig_type_info _swigt__p_wxStaticText[] = {{"_p_wxStaticText", 0, "wxStaticText *", 0, 0, 0, 0},{"_p_wxStaticText", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36680 static swig_type_info _swigt__p_wxControlWithItems[] = {{"_p_wxControlWithItems", 0, "wxControlWithItems *", 0, 0, 0, 0},{"_p_wxComboBox", _p_wxComboBoxTo_p_wxControlWithItems, 0, 0, 0, 0, 0},{"_p_wxDirFilterListCtrl", _p_wxDirFilterListCtrlTo_p_wxControlWithItems, 0, 0, 0, 0, 0},{"_p_wxChoice", _p_wxChoiceTo_p_wxControlWithItems, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", 0, 0, 0, 0, 0, 0},{"_p_wxListBox", _p_wxListBoxTo_p_wxControlWithItems, 0, 0, 0, 0, 0},{"_p_wxCheckListBox", _p_wxCheckListBoxTo_p_wxControlWithItems, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36681 static swig_type_info _swigt__p_wxToolBarToolBase[] = {{"_p_wxToolBarToolBase", 0, "wxToolBarToolBase *", 0, 0, 0, 0},{"_p_wxToolBarToolBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36682 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}};
36683 static swig_type_info _swigt__p_wxToolBar[] = {{"_p_wxToolBar", 0, "wxToolBar *", 0, 0, 0, 0},{"_p_wxToolBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36684 static swig_type_info _swigt__p_wxBookCtrlSizer[] = {{"_p_wxBookCtrlSizer", 0, "wxBookCtrlSizer *", 0, 0, 0, 0},{"_p_wxBookCtrlSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36685 static swig_type_info _swigt__p_wxValidator[] = {{"_p_wxValidator", 0, "wxValidator *", 0, 0, 0, 0},{"_p_wxValidator", 0, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxValidator, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
36686
36687 static swig_type_info *swig_types_initial[] = {
36688 _swigt__p_wxTextUrlEvent,
36689 _swigt__p_wxSizer,
36690 _swigt__p_wxCheckBox,
36691 _swigt__p_wxPyTreeCtrl,
36692 _swigt__p_wxEvent,
36693 _swigt__p_wxGenericDirCtrl,
36694 _swigt__p_bool,
36695 _swigt__p_wxItemContainer,
36696 _swigt__p_wxPyListCtrl,
36697 _swigt__p_wxPyTreeItemData,
36698 _swigt__p_wxDirFilterListCtrl,
36699 _swigt__p_wxStaticLine,
36700 _swigt__p_wxControl,
36701 _swigt__p_wxPyControl,
36702 _swigt__p_wxGauge,
36703 _swigt__p_wxToolBarBase,
36704 _swigt__p_wxFont,
36705 _swigt__p_wxToggleButton,
36706 _swigt__p_wxRadioButton,
36707 _swigt__p_wxChoice,
36708 _swigt__p_wxMemoryDC,
36709 _swigt__ptrdiff_t,
36710 _swigt__std__ptrdiff_t,
36711 _swigt__p_wxListItemAttr,
36712 _swigt__p_void,
36713 _swigt__p_int,
36714 _swigt__p_wxSize,
36715 _swigt__p_wxDC,
36716 _swigt__p_wxListView,
36717 _swigt__p_wxIcon,
36718 _swigt__p_wxVisualAttributes,
36719 _swigt__p_wxTextCtrl,
36720 _swigt__p_wxNotebook,
36721 _swigt__p_wxChoicebook,
36722 _swigt__p_wxNotifyEvent,
36723 _swigt__p_wxArrayString,
36724 _swigt__p_form_ops_t,
36725 _swigt__p_wxListbook,
36726 _swigt__p_wxStaticBitmap,
36727 _swigt__p_wxSlider,
36728 _swigt__p_wxStaticBox,
36729 _swigt__p_wxArrayInt,
36730 _swigt__p_wxContextHelp,
36731 _swigt__p_long,
36732 _swigt__p_wxDuplexMode,
36733 _swigt__p_wxBookCtrlBase,
36734 _swigt__p_wxEvtHandler,
36735 _swigt__p_wxListEvent,
36736 _swigt__p_wxCheckListBox,
36737 _swigt__p_wxListBox,
36738 _swigt__p_wxSpinButton,
36739 _swigt__p_wxButton,
36740 _swigt__p_wxBitmapButton,
36741 _swigt__p_wxRect,
36742 _swigt__p_wxContextHelpButton,
36743 _swigt__p_wxRadioBox,
36744 _swigt__p_wxScrollBar,
36745 _swigt__p_char,
36746 _swigt__p_wxComboBox,
36747 _swigt__p_wxTreeItemId,
36748 _swigt__p_wxHelpEvent,
36749 _swigt__p_wxListItem,
36750 _swigt__p_wxNotebookSizer,
36751 _swigt__p_wxSpinEvent,
36752 _swigt__p_wxGenericDragImage,
36753 _swigt__p_wxSpinCtrl,
36754 _swigt__p_wxPaperSize,
36755 _swigt__p_wxImageList,
36756 _swigt__p_wxHelpProvider,
36757 _swigt__p_wxTextAttr,
36758 _swigt__p_wxSimpleHelpProvider,
36759 _swigt__p_wxChoicebookEvent,
36760 _swigt__p_wxListbookEvent,
36761 _swigt__p_wxNotebookEvent,
36762 _swigt__p_wxPoint,
36763 _swigt__p_wxObject,
36764 _swigt__p_wxCursor,
36765 _swigt__p_wxKeyEvent,
36766 _swigt__p_unsigned_long,
36767 _swigt__p_wxWindow,
36768 _swigt__p_wxString,
36769 _swigt__p_wxBitmap,
36770 _swigt__unsigned_int,
36771 _swigt__p_unsigned_int,
36772 _swigt__p_unsigned_char,
36773 _swigt__p_wxMouseEvent,
36774 _swigt__p_wxBookCtrlBaseEvent,
36775 _swigt__p_wxTreeEvent,
36776 _swigt__p_wxCommandEvent,
36777 _swigt__p_wxStaticText,
36778 _swigt__p_wxControlWithItems,
36779 _swigt__p_wxToolBarToolBase,
36780 _swigt__p_wxColour,
36781 _swigt__p_wxToolBar,
36782 _swigt__p_wxBookCtrlSizer,
36783 _swigt__p_wxValidator,
36784 0
36785 };
36786
36787
36788 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
36789
36790 static swig_const_info swig_const_table[] = {
36791 {0, 0, 0, 0.0, 0, 0}};
36792
36793 #ifdef __cplusplus
36794 }
36795 #endif
36796
36797
36798 #ifdef __cplusplus
36799 extern "C" {
36800 #endif
36801
36802     /* Python-specific SWIG API */
36803 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
36804 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
36805 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
36806
36807     /* -----------------------------------------------------------------------------
36808      * global variable support code.
36809      * ----------------------------------------------------------------------------- */
36810
36811     typedef struct swig_globalvar {
36812         char       *name;                  /* Name of global variable */
36813         PyObject *(*get_attr)();           /* Return the current value */
36814         int       (*set_attr)(PyObject *); /* Set the value */
36815         struct swig_globalvar *next;
36816     } swig_globalvar;
36817
36818     typedef struct swig_varlinkobject {
36819         PyObject_HEAD
36820         swig_globalvar *vars;
36821     } swig_varlinkobject;
36822
36823     static PyObject *
36824     swig_varlink_repr(swig_varlinkobject *v) {
36825         v = v;
36826         return PyString_FromString("<Swig global variables>");
36827     }
36828
36829     static int
36830     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
36831         swig_globalvar  *var;
36832         flags = flags;
36833         fprintf(fp,"Swig global variables { ");
36834         for (var = v->vars; var; var=var->next) {
36835             fprintf(fp,"%s", var->name);
36836             if (var->next) fprintf(fp,", ");
36837         }
36838         fprintf(fp," }\n");
36839         return 0;
36840     }
36841
36842     static PyObject *
36843     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
36844         swig_globalvar *var = v->vars;
36845         while (var) {
36846             if (strcmp(var->name,n) == 0) {
36847                 return (*var->get_attr)();
36848             }
36849             var = var->next;
36850         }
36851         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36852         return NULL;
36853     }
36854
36855     static int
36856     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
36857         swig_globalvar *var = v->vars;
36858         while (var) {
36859             if (strcmp(var->name,n) == 0) {
36860                 return (*var->set_attr)(p);
36861             }
36862             var = var->next;
36863         }
36864         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36865         return 1;
36866     }
36867
36868     static PyTypeObject varlinktype = {
36869         PyObject_HEAD_INIT(0)
36870         0,                                  /* Number of items in variable part (ob_size) */
36871         (char *)"swigvarlink",              /* Type name (tp_name) */
36872         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
36873         0,                                  /* Itemsize (tp_itemsize) */
36874         0,                                  /* Deallocator (tp_dealloc) */
36875         (printfunc) swig_varlink_print,     /* Print (tp_print) */
36876         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
36877         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
36878         0,                                  /* tp_compare */
36879         (reprfunc) swig_varlink_repr,       /* tp_repr */
36880         0,                                  /* tp_as_number */
36881         0,                                  /* tp_as_sequence */
36882         0,                                  /* tp_as_mapping */
36883         0,                                  /* tp_hash */
36884         0,                                  /* tp_call */
36885         0,                                  /* tp_str */
36886         0,                                  /* tp_getattro */
36887         0,                                  /* tp_setattro */
36888         0,                                  /* tp_as_buffer */
36889         0,                                  /* tp_flags */
36890         0,                                  /* tp_doc */
36891 #if PY_VERSION_HEX >= 0x02000000
36892         0,                                  /* tp_traverse */
36893         0,                                  /* tp_clear */
36894 #endif
36895 #if PY_VERSION_HEX >= 0x02010000
36896         0,                                  /* tp_richcompare */
36897         0,                                  /* tp_weaklistoffset */
36898 #endif
36899 #if PY_VERSION_HEX >= 0x02020000
36900         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
36901 #endif
36902 #if PY_VERSION_HEX >= 0x02030000
36903         0,                                  /* tp_del */
36904 #endif
36905 #ifdef COUNT_ALLOCS
36906         0,0,0,0                             /* tp_alloc -> tp_next */
36907 #endif
36908     };
36909
36910     /* Create a variable linking object for use later */
36911     static PyObject *
36912     SWIG_Python_newvarlink(void) {
36913         swig_varlinkobject *result = 0;
36914         result = PyMem_NEW(swig_varlinkobject,1);
36915         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
36916         result->ob_type = &varlinktype;
36917         result->vars = 0;
36918         result->ob_refcnt = 0;
36919         Py_XINCREF((PyObject *) result);
36920         return ((PyObject*) result);
36921     }
36922
36923     static void
36924     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
36925         swig_varlinkobject *v;
36926         swig_globalvar *gv;
36927         v= (swig_varlinkobject *) p;
36928         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
36929         gv->name = (char *) malloc(strlen(name)+1);
36930         strcpy(gv->name,name);
36931         gv->get_attr = get_attr;
36932         gv->set_attr = set_attr;
36933         gv->next = v->vars;
36934         v->vars = gv;
36935     }
36936
36937     /* -----------------------------------------------------------------------------
36938      * constants/methods manipulation
36939      * ----------------------------------------------------------------------------- */
36940
36941     /* Install Constants */
36942     static void
36943     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
36944         PyObject *obj = 0;
36945         size_t i;
36946         for (i = 0; constants[i].type; i++) {
36947             switch(constants[i].type) {
36948                 case SWIG_PY_INT:
36949                 obj = PyInt_FromLong(constants[i].lvalue);
36950                 break;
36951                 case SWIG_PY_FLOAT:
36952                 obj = PyFloat_FromDouble(constants[i].dvalue);
36953                 break;
36954                 case SWIG_PY_STRING:
36955                 if (constants[i].pvalue) {
36956                     obj = PyString_FromString((char *) constants[i].pvalue);
36957                 } else {
36958                     Py_INCREF(Py_None);
36959                     obj = Py_None;
36960                 }
36961                 break;
36962                 case SWIG_PY_POINTER:
36963                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
36964                 break;
36965                 case SWIG_PY_BINARY:
36966                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
36967                 break;
36968                 default:
36969                 obj = 0;
36970                 break;
36971             }
36972             if (obj) {
36973                 PyDict_SetItemString(d,constants[i].name,obj);
36974                 Py_DECREF(obj);
36975             }
36976         }
36977     }
36978
36979     /* -----------------------------------------------------------------------------*/
36980     /* Fix SwigMethods to carry the callback ptrs when needed */
36981     /* -----------------------------------------------------------------------------*/
36982
36983     static void
36984     SWIG_Python_FixMethods(PyMethodDef *methods,
36985     swig_const_info *const_table,
36986     swig_type_info **types,
36987     swig_type_info **types_initial) {
36988         size_t i;
36989         for (i = 0; methods[i].ml_name; ++i) {
36990             char *c = methods[i].ml_doc;
36991             if (c && (c = strstr(c, "swig_ptr: "))) {
36992                 int j;
36993                 swig_const_info *ci = 0;
36994                 char *name = c + 10;
36995                 for (j = 0; const_table[j].type; j++) {
36996                     if (strncmp(const_table[j].name, name,
36997                     strlen(const_table[j].name)) == 0) {
36998                         ci = &(const_table[j]);
36999                         break;
37000                     }
37001                 }
37002                 if (ci) {
37003                     size_t shift = (ci->ptype) - types;
37004                     swig_type_info *ty = types_initial[shift];
37005                     size_t ldoc = (c - methods[i].ml_doc);
37006                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
37007                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
37008                     char *buff = ndoc;
37009                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
37010                     strncpy(buff, methods[i].ml_doc, ldoc);
37011                     buff += ldoc;
37012                     strncpy(buff, "swig_ptr: ", 10);
37013                     buff += 10;
37014                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
37015                     methods[i].ml_doc = ndoc;
37016                 }
37017             }
37018         }
37019     }
37020
37021     /* -----------------------------------------------------------------------------*
37022      *  Initialize type list
37023      * -----------------------------------------------------------------------------*/
37024
37025 #if PY_MAJOR_VERSION < 2
37026     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
37027     is copied out of Python/modsupport.c in python version 2.3.4 */
37028     static int
37029     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
37030     {
37031         PyObject *dict;
37032         if (!PyModule_Check(m)) {
37033             PyErr_SetString(PyExc_TypeError,
37034             "PyModule_AddObject() needs module as first arg");
37035             return -1;
37036         }
37037         if (!o) {
37038             PyErr_SetString(PyExc_TypeError,
37039             "PyModule_AddObject() needs non-NULL value");
37040             return -1;
37041         }
37042
37043         dict = PyModule_GetDict(m);
37044         if (dict == NULL) {
37045             /* Internal error -- modules must have a dict! */
37046             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
37047             PyModule_GetName(m));
37048             return -1;
37049         }
37050         if (PyDict_SetItemString(dict, name, o))
37051         return -1;
37052         Py_DECREF(o);
37053         return 0;
37054     }
37055 #endif
37056
37057     static swig_type_info **
37058     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
37059         static PyMethodDef swig_empty_runtime_method_table[] = {
37060             {
37061                 NULL, NULL, 0, NULL
37062             }
37063         };/* Sentinel */
37064
37065         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
37066         swig_empty_runtime_method_table);
37067         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
37068         if (pointer && module) {
37069             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
37070         }
37071         return type_list_handle;
37072     }
37073
37074     static swig_type_info **
37075     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
37076         swig_type_info **type_pointer;
37077
37078         /* first check if module already created */
37079         type_pointer = SWIG_Python_GetTypeListHandle();
37080         if (type_pointer) {
37081             return type_pointer;
37082         } else {
37083             /* create a new module and variable */
37084             return SWIG_Python_SetTypeListHandle(type_list_handle);
37085         }
37086     }
37087
37088 #ifdef __cplusplus
37089 }
37090 #endif
37091
37092 /* -----------------------------------------------------------------------------*
37093  *  Partial Init method
37094  * -----------------------------------------------------------------------------*/
37095
37096 #ifdef SWIG_LINK_RUNTIME
37097 #ifdef __cplusplus
37098 extern "C"
37099 #endif
37100 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
37101 #endif
37102
37103 #ifdef __cplusplus
37104 extern "C"
37105 #endif
37106 SWIGEXPORT(void) SWIG_init(void) {
37107     static PyObject *SWIG_globals = 0;
37108     static int       typeinit = 0;
37109     PyObject *m, *d;
37110     int       i;
37111     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
37112
37113     /* Fix SwigMethods to carry the callback ptrs when needed */
37114     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
37115
37116     m = Py_InitModule((char *) SWIG_name, SwigMethods);
37117     d = PyModule_GetDict(m);
37118
37119     if (!typeinit) {
37120 #ifdef SWIG_LINK_RUNTIME
37121         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
37122 #else
37123 #  ifndef SWIG_STATIC_RUNTIME
37124         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
37125 #  endif
37126 #endif
37127         for (i = 0; swig_types_initial[i]; i++) {
37128             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
37129         }
37130         typeinit = 1;
37131     }
37132     SWIG_InstallConstants(d,swig_const_table);
37133
37134     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
37135     SWIG_addvarlink(SWIG_globals,(char*)"ButtonNameStr",_wrap_ButtonNameStr_get, _wrap_ButtonNameStr_set);
37136     {
37137         PyDict_SetItemString(d,"BU_LEFT", SWIG_From_int((int)(wxBU_LEFT)));
37138     }
37139     {
37140         PyDict_SetItemString(d,"BU_TOP", SWIG_From_int((int)(wxBU_TOP)));
37141     }
37142     {
37143         PyDict_SetItemString(d,"BU_RIGHT", SWIG_From_int((int)(wxBU_RIGHT)));
37144     }
37145     {
37146         PyDict_SetItemString(d,"BU_BOTTOM", SWIG_From_int((int)(wxBU_BOTTOM)));
37147     }
37148     {
37149         PyDict_SetItemString(d,"BU_ALIGN_MASK", SWIG_From_int((int)(wxBU_ALIGN_MASK)));
37150     }
37151     {
37152         PyDict_SetItemString(d,"BU_EXACTFIT", SWIG_From_int((int)(wxBU_EXACTFIT)));
37153     }
37154     {
37155         PyDict_SetItemString(d,"BU_AUTODRAW", SWIG_From_int((int)(wxBU_AUTODRAW)));
37156     }
37157     SWIG_addvarlink(SWIG_globals,(char*)"CheckBoxNameStr",_wrap_CheckBoxNameStr_get, _wrap_CheckBoxNameStr_set);
37158     {
37159         PyDict_SetItemString(d,"CHK_2STATE", SWIG_From_int((int)(wxCHK_2STATE)));
37160     }
37161     {
37162         PyDict_SetItemString(d,"CHK_3STATE", SWIG_From_int((int)(wxCHK_3STATE)));
37163     }
37164     {
37165         PyDict_SetItemString(d,"CHK_ALLOW_3RD_STATE_FOR_USER", SWIG_From_int((int)(wxCHK_ALLOW_3RD_STATE_FOR_USER)));
37166     }
37167     {
37168         PyDict_SetItemString(d,"CHK_UNCHECKED", SWIG_From_int((int)(wxCHK_UNCHECKED)));
37169     }
37170     {
37171         PyDict_SetItemString(d,"CHK_CHECKED", SWIG_From_int((int)(wxCHK_CHECKED)));
37172     }
37173     {
37174         PyDict_SetItemString(d,"CHK_UNDETERMINED", SWIG_From_int((int)(wxCHK_UNDETERMINED)));
37175     }
37176     SWIG_addvarlink(SWIG_globals,(char*)"ChoiceNameStr",_wrap_ChoiceNameStr_get, _wrap_ChoiceNameStr_set);
37177     SWIG_addvarlink(SWIG_globals,(char*)"ComboBoxNameStr",_wrap_ComboBoxNameStr_get, _wrap_ComboBoxNameStr_set);
37178     SWIG_addvarlink(SWIG_globals,(char*)"GaugeNameStr",_wrap_GaugeNameStr_get, _wrap_GaugeNameStr_set);
37179     {
37180         PyDict_SetItemString(d,"GA_HORIZONTAL", SWIG_From_int((int)(wxGA_HORIZONTAL)));
37181     }
37182     {
37183         PyDict_SetItemString(d,"GA_VERTICAL", SWIG_From_int((int)(wxGA_VERTICAL)));
37184     }
37185     {
37186         PyDict_SetItemString(d,"GA_SMOOTH", SWIG_From_int((int)(wxGA_SMOOTH)));
37187     }
37188     {
37189         PyDict_SetItemString(d,"GA_PROGRESSBAR", SWIG_From_int((int)(wxGA_PROGRESSBAR)));
37190     }
37191     SWIG_addvarlink(SWIG_globals,(char*)"StaticBitmapNameStr",_wrap_StaticBitmapNameStr_get, _wrap_StaticBitmapNameStr_set);
37192     SWIG_addvarlink(SWIG_globals,(char*)"StaticBoxNameStr",_wrap_StaticBoxNameStr_get, _wrap_StaticBoxNameStr_set);
37193     SWIG_addvarlink(SWIG_globals,(char*)"StaticTextNameStr",_wrap_StaticTextNameStr_get, _wrap_StaticTextNameStr_set);
37194     SWIG_addvarlink(SWIG_globals,(char*)"ListBoxNameStr",_wrap_ListBoxNameStr_get, _wrap_ListBoxNameStr_set);
37195     SWIG_addvarlink(SWIG_globals,(char*)"TextCtrlNameStr",_wrap_TextCtrlNameStr_get, _wrap_TextCtrlNameStr_set);
37196     {
37197         PyDict_SetItemString(d,"TE_NO_VSCROLL", SWIG_From_int((int)(wxTE_NO_VSCROLL)));
37198     }
37199     {
37200         PyDict_SetItemString(d,"TE_AUTO_SCROLL", SWIG_From_int((int)(wxTE_AUTO_SCROLL)));
37201     }
37202     {
37203         PyDict_SetItemString(d,"TE_READONLY", SWIG_From_int((int)(wxTE_READONLY)));
37204     }
37205     {
37206         PyDict_SetItemString(d,"TE_MULTILINE", SWIG_From_int((int)(wxTE_MULTILINE)));
37207     }
37208     {
37209         PyDict_SetItemString(d,"TE_PROCESS_TAB", SWIG_From_int((int)(wxTE_PROCESS_TAB)));
37210     }
37211     {
37212         PyDict_SetItemString(d,"TE_LEFT", SWIG_From_int((int)(wxTE_LEFT)));
37213     }
37214     {
37215         PyDict_SetItemString(d,"TE_CENTER", SWIG_From_int((int)(wxTE_CENTER)));
37216     }
37217     {
37218         PyDict_SetItemString(d,"TE_RIGHT", SWIG_From_int((int)(wxTE_RIGHT)));
37219     }
37220     {
37221         PyDict_SetItemString(d,"TE_CENTRE", SWIG_From_int((int)(wxTE_CENTRE)));
37222     }
37223     {
37224         PyDict_SetItemString(d,"TE_RICH", SWIG_From_int((int)(wxTE_RICH)));
37225     }
37226     {
37227         PyDict_SetItemString(d,"TE_PROCESS_ENTER", SWIG_From_int((int)(wxTE_PROCESS_ENTER)));
37228     }
37229     {
37230         PyDict_SetItemString(d,"TE_PASSWORD", SWIG_From_int((int)(wxTE_PASSWORD)));
37231     }
37232     {
37233         PyDict_SetItemString(d,"TE_AUTO_URL", SWIG_From_int((int)(wxTE_AUTO_URL)));
37234     }
37235     {
37236         PyDict_SetItemString(d,"TE_NOHIDESEL", SWIG_From_int((int)(wxTE_NOHIDESEL)));
37237     }
37238     {
37239         PyDict_SetItemString(d,"TE_DONTWRAP", SWIG_From_int((int)(wxTE_DONTWRAP)));
37240     }
37241     {
37242         PyDict_SetItemString(d,"TE_LINEWRAP", SWIG_From_int((int)(wxTE_LINEWRAP)));
37243     }
37244     {
37245         PyDict_SetItemString(d,"TE_WORDWRAP", SWIG_From_int((int)(wxTE_WORDWRAP)));
37246     }
37247     {
37248         PyDict_SetItemString(d,"TE_RICH2", SWIG_From_int((int)(wxTE_RICH2)));
37249     }
37250     {
37251         PyDict_SetItemString(d,"TEXT_ALIGNMENT_DEFAULT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_DEFAULT)));
37252     }
37253     {
37254         PyDict_SetItemString(d,"TEXT_ALIGNMENT_LEFT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_LEFT)));
37255     }
37256     {
37257         PyDict_SetItemString(d,"TEXT_ALIGNMENT_CENTRE", SWIG_From_int((int)(wxTEXT_ALIGNMENT_CENTRE)));
37258     }
37259     {
37260         PyDict_SetItemString(d,"TEXT_ALIGNMENT_CENTER", SWIG_From_int((int)(wxTEXT_ALIGNMENT_CENTER)));
37261     }
37262     {
37263         PyDict_SetItemString(d,"TEXT_ALIGNMENT_RIGHT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_RIGHT)));
37264     }
37265     {
37266         PyDict_SetItemString(d,"TEXT_ALIGNMENT_JUSTIFIED", SWIG_From_int((int)(wxTEXT_ALIGNMENT_JUSTIFIED)));
37267     }
37268     {
37269         PyDict_SetItemString(d,"TEXT_ATTR_TEXT_COLOUR", SWIG_From_int((int)(wxTEXT_ATTR_TEXT_COLOUR)));
37270     }
37271     {
37272         PyDict_SetItemString(d,"TEXT_ATTR_BACKGROUND_COLOUR", SWIG_From_int((int)(wxTEXT_ATTR_BACKGROUND_COLOUR)));
37273     }
37274     {
37275         PyDict_SetItemString(d,"TEXT_ATTR_FONT_FACE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_FACE)));
37276     }
37277     {
37278         PyDict_SetItemString(d,"TEXT_ATTR_FONT_SIZE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_SIZE)));
37279     }
37280     {
37281         PyDict_SetItemString(d,"TEXT_ATTR_FONT_WEIGHT", SWIG_From_int((int)(wxTEXT_ATTR_FONT_WEIGHT)));
37282     }
37283     {
37284         PyDict_SetItemString(d,"TEXT_ATTR_FONT_ITALIC", SWIG_From_int((int)(wxTEXT_ATTR_FONT_ITALIC)));
37285     }
37286     {
37287         PyDict_SetItemString(d,"TEXT_ATTR_FONT_UNDERLINE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_UNDERLINE)));
37288     }
37289     {
37290         PyDict_SetItemString(d,"TEXT_ATTR_FONT", SWIG_From_int((int)(wxTEXT_ATTR_FONT)));
37291     }
37292     {
37293         PyDict_SetItemString(d,"TEXT_ATTR_ALIGNMENT", SWIG_From_int((int)(wxTEXT_ATTR_ALIGNMENT)));
37294     }
37295     {
37296         PyDict_SetItemString(d,"TEXT_ATTR_LEFT_INDENT", SWIG_From_int((int)(wxTEXT_ATTR_LEFT_INDENT)));
37297     }
37298     {
37299         PyDict_SetItemString(d,"TEXT_ATTR_RIGHT_INDENT", SWIG_From_int((int)(wxTEXT_ATTR_RIGHT_INDENT)));
37300     }
37301     {
37302         PyDict_SetItemString(d,"TEXT_ATTR_TABS", SWIG_From_int((int)(wxTEXT_ATTR_TABS)));
37303     }
37304     {
37305         PyDict_SetItemString(d,"TE_HT_UNKNOWN", SWIG_From_int((int)(wxTE_HT_UNKNOWN)));
37306     }
37307     {
37308         PyDict_SetItemString(d,"TE_HT_BEFORE", SWIG_From_int((int)(wxTE_HT_BEFORE)));
37309     }
37310     {
37311         PyDict_SetItemString(d,"TE_HT_ON_TEXT", SWIG_From_int((int)(wxTE_HT_ON_TEXT)));
37312     }
37313     {
37314         PyDict_SetItemString(d,"TE_HT_BELOW", SWIG_From_int((int)(wxTE_HT_BELOW)));
37315     }
37316     {
37317         PyDict_SetItemString(d,"TE_HT_BEYOND", SWIG_From_int((int)(wxTE_HT_BEYOND)));
37318     }
37319     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_UPDATED", PyInt_FromLong(wxEVT_COMMAND_TEXT_UPDATED));
37320     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_ENTER", PyInt_FromLong(wxEVT_COMMAND_TEXT_ENTER));
37321     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_URL", PyInt_FromLong(wxEVT_COMMAND_TEXT_URL));
37322     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_MAXLEN", PyInt_FromLong(wxEVT_COMMAND_TEXT_MAXLEN));
37323     SWIG_addvarlink(SWIG_globals,(char*)"ScrollBarNameStr",_wrap_ScrollBarNameStr_get, _wrap_ScrollBarNameStr_set);
37324     SWIG_addvarlink(SWIG_globals,(char*)"SPIN_BUTTON_NAME",_wrap_SPIN_BUTTON_NAME_get, _wrap_SPIN_BUTTON_NAME_set);
37325     SWIG_addvarlink(SWIG_globals,(char*)"SpinCtrlNameStr",_wrap_SpinCtrlNameStr_get, _wrap_SpinCtrlNameStr_set);
37326     {
37327         PyDict_SetItemString(d,"SP_HORIZONTAL", SWIG_From_int((int)(wxSP_HORIZONTAL)));
37328     }
37329     {
37330         PyDict_SetItemString(d,"SP_VERTICAL", SWIG_From_int((int)(wxSP_VERTICAL)));
37331     }
37332     {
37333         PyDict_SetItemString(d,"SP_ARROW_KEYS", SWIG_From_int((int)(wxSP_ARROW_KEYS)));
37334     }
37335     {
37336         PyDict_SetItemString(d,"SP_WRAP", SWIG_From_int((int)(wxSP_WRAP)));
37337     }
37338     PyDict_SetItemString(d, "wxEVT_COMMAND_SPINCTRL_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SPINCTRL_UPDATED));
37339     SWIG_addvarlink(SWIG_globals,(char*)"RadioBoxNameStr",_wrap_RadioBoxNameStr_get, _wrap_RadioBoxNameStr_set);
37340     SWIG_addvarlink(SWIG_globals,(char*)"RadioButtonNameStr",_wrap_RadioButtonNameStr_get, _wrap_RadioButtonNameStr_set);
37341     SWIG_addvarlink(SWIG_globals,(char*)"SliderNameStr",_wrap_SliderNameStr_get, _wrap_SliderNameStr_set);
37342     SWIG_addvarlink(SWIG_globals,(char*)"ToggleButtonNameStr",_wrap_ToggleButtonNameStr_get, _wrap_ToggleButtonNameStr_set);
37343     PyDict_SetItemString(d, "wxEVT_COMMAND_TOGGLEBUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED));
37344     SWIG_addvarlink(SWIG_globals,(char*)"NOTEBOOK_NAME",_wrap_NOTEBOOK_NAME_get, _wrap_NOTEBOOK_NAME_set);
37345     {
37346         PyDict_SetItemString(d,"NB_FIXEDWIDTH", SWIG_From_int((int)(wxNB_FIXEDWIDTH)));
37347     }
37348     {
37349         PyDict_SetItemString(d,"NB_TOP", SWIG_From_int((int)(wxNB_TOP)));
37350     }
37351     {
37352         PyDict_SetItemString(d,"NB_LEFT", SWIG_From_int((int)(wxNB_LEFT)));
37353     }
37354     {
37355         PyDict_SetItemString(d,"NB_RIGHT", SWIG_From_int((int)(wxNB_RIGHT)));
37356     }
37357     {
37358         PyDict_SetItemString(d,"NB_BOTTOM", SWIG_From_int((int)(wxNB_BOTTOM)));
37359     }
37360     {
37361         PyDict_SetItemString(d,"NB_MULTILINE", SWIG_From_int((int)(wxNB_MULTILINE)));
37362     }
37363     {
37364         PyDict_SetItemString(d,"NB_HITTEST_NOWHERE", SWIG_From_int((int)(wxNB_HITTEST_NOWHERE)));
37365     }
37366     {
37367         PyDict_SetItemString(d,"NB_HITTEST_ONICON", SWIG_From_int((int)(wxNB_HITTEST_ONICON)));
37368     }
37369     {
37370         PyDict_SetItemString(d,"NB_HITTEST_ONLABEL", SWIG_From_int((int)(wxNB_HITTEST_ONLABEL)));
37371     }
37372     {
37373         PyDict_SetItemString(d,"NB_HITTEST_ONITEM", SWIG_From_int((int)(wxNB_HITTEST_ONITEM)));
37374     }
37375     PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED));
37376     PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING));
37377     {
37378         PyDict_SetItemString(d,"LB_DEFAULT", SWIG_From_int((int)(wxLB_DEFAULT)));
37379     }
37380     {
37381         PyDict_SetItemString(d,"LB_TOP", SWIG_From_int((int)(wxLB_TOP)));
37382     }
37383     {
37384         PyDict_SetItemString(d,"LB_BOTTOM", SWIG_From_int((int)(wxLB_BOTTOM)));
37385     }
37386     {
37387         PyDict_SetItemString(d,"LB_LEFT", SWIG_From_int((int)(wxLB_LEFT)));
37388     }
37389     {
37390         PyDict_SetItemString(d,"LB_RIGHT", SWIG_From_int((int)(wxLB_RIGHT)));
37391     }
37392     {
37393         PyDict_SetItemString(d,"LB_ALIGN_MASK", SWIG_From_int((int)(wxLB_ALIGN_MASK)));
37394     }
37395     PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED));
37396     PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING));
37397     {
37398         PyDict_SetItemString(d,"CHB_DEFAULT", SWIG_From_int((int)(wxCHB_DEFAULT)));
37399     }
37400     {
37401         PyDict_SetItemString(d,"CHB_TOP", SWIG_From_int((int)(wxCHB_TOP)));
37402     }
37403     {
37404         PyDict_SetItemString(d,"CHB_BOTTOM", SWIG_From_int((int)(wxCHB_BOTTOM)));
37405     }
37406     {
37407         PyDict_SetItemString(d,"CHB_LEFT", SWIG_From_int((int)(wxCHB_LEFT)));
37408     }
37409     {
37410         PyDict_SetItemString(d,"CHB_RIGHT", SWIG_From_int((int)(wxCHB_RIGHT)));
37411     }
37412     {
37413         PyDict_SetItemString(d,"CHB_ALIGN_MASK", SWIG_From_int((int)(wxCHB_ALIGN_MASK)));
37414     }
37415     PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED));
37416     PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING));
37417     {
37418         PyDict_SetItemString(d,"TOOL_STYLE_BUTTON", SWIG_From_int((int)(wxTOOL_STYLE_BUTTON)));
37419     }
37420     {
37421         PyDict_SetItemString(d,"TOOL_STYLE_SEPARATOR", SWIG_From_int((int)(wxTOOL_STYLE_SEPARATOR)));
37422     }
37423     {
37424         PyDict_SetItemString(d,"TOOL_STYLE_CONTROL", SWIG_From_int((int)(wxTOOL_STYLE_CONTROL)));
37425     }
37426     {
37427         PyDict_SetItemString(d,"TB_HORIZONTAL", SWIG_From_int((int)(wxTB_HORIZONTAL)));
37428     }
37429     {
37430         PyDict_SetItemString(d,"TB_VERTICAL", SWIG_From_int((int)(wxTB_VERTICAL)));
37431     }
37432     {
37433         PyDict_SetItemString(d,"TB_3DBUTTONS", SWIG_From_int((int)(wxTB_3DBUTTONS)));
37434     }
37435     {
37436         PyDict_SetItemString(d,"TB_FLAT", SWIG_From_int((int)(wxTB_FLAT)));
37437     }
37438     {
37439         PyDict_SetItemString(d,"TB_DOCKABLE", SWIG_From_int((int)(wxTB_DOCKABLE)));
37440     }
37441     {
37442         PyDict_SetItemString(d,"TB_NOICONS", SWIG_From_int((int)(wxTB_NOICONS)));
37443     }
37444     {
37445         PyDict_SetItemString(d,"TB_TEXT", SWIG_From_int((int)(wxTB_TEXT)));
37446     }
37447     {
37448         PyDict_SetItemString(d,"TB_NODIVIDER", SWIG_From_int((int)(wxTB_NODIVIDER)));
37449     }
37450     {
37451         PyDict_SetItemString(d,"TB_NOALIGN", SWIG_From_int((int)(wxTB_NOALIGN)));
37452     }
37453     {
37454         PyDict_SetItemString(d,"TB_HORZ_LAYOUT", SWIG_From_int((int)(wxTB_HORZ_LAYOUT)));
37455     }
37456     {
37457         PyDict_SetItemString(d,"TB_HORZ_TEXT", SWIG_From_int((int)(wxTB_HORZ_TEXT)));
37458     }
37459     SWIG_addvarlink(SWIG_globals,(char*)"ListCtrlNameStr",_wrap_ListCtrlNameStr_get, _wrap_ListCtrlNameStr_set);
37460     {
37461         PyDict_SetItemString(d,"LC_VRULES", SWIG_From_int((int)(wxLC_VRULES)));
37462     }
37463     {
37464         PyDict_SetItemString(d,"LC_HRULES", SWIG_From_int((int)(wxLC_HRULES)));
37465     }
37466     {
37467         PyDict_SetItemString(d,"LC_ICON", SWIG_From_int((int)(wxLC_ICON)));
37468     }
37469     {
37470         PyDict_SetItemString(d,"LC_SMALL_ICON", SWIG_From_int((int)(wxLC_SMALL_ICON)));
37471     }
37472     {
37473         PyDict_SetItemString(d,"LC_LIST", SWIG_From_int((int)(wxLC_LIST)));
37474     }
37475     {
37476         PyDict_SetItemString(d,"LC_REPORT", SWIG_From_int((int)(wxLC_REPORT)));
37477     }
37478     {
37479         PyDict_SetItemString(d,"LC_ALIGN_TOP", SWIG_From_int((int)(wxLC_ALIGN_TOP)));
37480     }
37481     {
37482         PyDict_SetItemString(d,"LC_ALIGN_LEFT", SWIG_From_int((int)(wxLC_ALIGN_LEFT)));
37483     }
37484     {
37485         PyDict_SetItemString(d,"LC_AUTOARRANGE", SWIG_From_int((int)(wxLC_AUTOARRANGE)));
37486     }
37487     {
37488         PyDict_SetItemString(d,"LC_VIRTUAL", SWIG_From_int((int)(wxLC_VIRTUAL)));
37489     }
37490     {
37491         PyDict_SetItemString(d,"LC_EDIT_LABELS", SWIG_From_int((int)(wxLC_EDIT_LABELS)));
37492     }
37493     {
37494         PyDict_SetItemString(d,"LC_NO_HEADER", SWIG_From_int((int)(wxLC_NO_HEADER)));
37495     }
37496     {
37497         PyDict_SetItemString(d,"LC_NO_SORT_HEADER", SWIG_From_int((int)(wxLC_NO_SORT_HEADER)));
37498     }
37499     {
37500         PyDict_SetItemString(d,"LC_SINGLE_SEL", SWIG_From_int((int)(wxLC_SINGLE_SEL)));
37501     }
37502     {
37503         PyDict_SetItemString(d,"LC_SORT_ASCENDING", SWIG_From_int((int)(wxLC_SORT_ASCENDING)));
37504     }
37505     {
37506         PyDict_SetItemString(d,"LC_SORT_DESCENDING", SWIG_From_int((int)(wxLC_SORT_DESCENDING)));
37507     }
37508     {
37509         PyDict_SetItemString(d,"LC_MASK_TYPE", SWIG_From_int((int)(wxLC_MASK_TYPE)));
37510     }
37511     {
37512         PyDict_SetItemString(d,"LC_MASK_ALIGN", SWIG_From_int((int)(wxLC_MASK_ALIGN)));
37513     }
37514     {
37515         PyDict_SetItemString(d,"LC_MASK_SORT", SWIG_From_int((int)(wxLC_MASK_SORT)));
37516     }
37517     {
37518         PyDict_SetItemString(d,"LIST_MASK_STATE", SWIG_From_int((int)(wxLIST_MASK_STATE)));
37519     }
37520     {
37521         PyDict_SetItemString(d,"LIST_MASK_TEXT", SWIG_From_int((int)(wxLIST_MASK_TEXT)));
37522     }
37523     {
37524         PyDict_SetItemString(d,"LIST_MASK_IMAGE", SWIG_From_int((int)(wxLIST_MASK_IMAGE)));
37525     }
37526     {
37527         PyDict_SetItemString(d,"LIST_MASK_DATA", SWIG_From_int((int)(wxLIST_MASK_DATA)));
37528     }
37529     {
37530         PyDict_SetItemString(d,"LIST_SET_ITEM", SWIG_From_int((int)(wxLIST_SET_ITEM)));
37531     }
37532     {
37533         PyDict_SetItemString(d,"LIST_MASK_WIDTH", SWIG_From_int((int)(wxLIST_MASK_WIDTH)));
37534     }
37535     {
37536         PyDict_SetItemString(d,"LIST_MASK_FORMAT", SWIG_From_int((int)(wxLIST_MASK_FORMAT)));
37537     }
37538     {
37539         PyDict_SetItemString(d,"LIST_STATE_DONTCARE", SWIG_From_int((int)(wxLIST_STATE_DONTCARE)));
37540     }
37541     {
37542         PyDict_SetItemString(d,"LIST_STATE_DROPHILITED", SWIG_From_int((int)(wxLIST_STATE_DROPHILITED)));
37543     }
37544     {
37545         PyDict_SetItemString(d,"LIST_STATE_FOCUSED", SWIG_From_int((int)(wxLIST_STATE_FOCUSED)));
37546     }
37547     {
37548         PyDict_SetItemString(d,"LIST_STATE_SELECTED", SWIG_From_int((int)(wxLIST_STATE_SELECTED)));
37549     }
37550     {
37551         PyDict_SetItemString(d,"LIST_STATE_CUT", SWIG_From_int((int)(wxLIST_STATE_CUT)));
37552     }
37553     {
37554         PyDict_SetItemString(d,"LIST_STATE_DISABLED", SWIG_From_int((int)(wxLIST_STATE_DISABLED)));
37555     }
37556     {
37557         PyDict_SetItemString(d,"LIST_STATE_FILTERED", SWIG_From_int((int)(wxLIST_STATE_FILTERED)));
37558     }
37559     {
37560         PyDict_SetItemString(d,"LIST_STATE_INUSE", SWIG_From_int((int)(wxLIST_STATE_INUSE)));
37561     }
37562     {
37563         PyDict_SetItemString(d,"LIST_STATE_PICKED", SWIG_From_int((int)(wxLIST_STATE_PICKED)));
37564     }
37565     {
37566         PyDict_SetItemString(d,"LIST_STATE_SOURCE", SWIG_From_int((int)(wxLIST_STATE_SOURCE)));
37567     }
37568     {
37569         PyDict_SetItemString(d,"LIST_HITTEST_ABOVE", SWIG_From_int((int)(wxLIST_HITTEST_ABOVE)));
37570     }
37571     {
37572         PyDict_SetItemString(d,"LIST_HITTEST_BELOW", SWIG_From_int((int)(wxLIST_HITTEST_BELOW)));
37573     }
37574     {
37575         PyDict_SetItemString(d,"LIST_HITTEST_NOWHERE", SWIG_From_int((int)(wxLIST_HITTEST_NOWHERE)));
37576     }
37577     {
37578         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMICON", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMICON)));
37579     }
37580     {
37581         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMLABEL", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMLABEL)));
37582     }
37583     {
37584         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMRIGHT", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMRIGHT)));
37585     }
37586     {
37587         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMSTATEICON", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMSTATEICON)));
37588     }
37589     {
37590         PyDict_SetItemString(d,"LIST_HITTEST_TOLEFT", SWIG_From_int((int)(wxLIST_HITTEST_TOLEFT)));
37591     }
37592     {
37593         PyDict_SetItemString(d,"LIST_HITTEST_TORIGHT", SWIG_From_int((int)(wxLIST_HITTEST_TORIGHT)));
37594     }
37595     {
37596         PyDict_SetItemString(d,"LIST_HITTEST_ONITEM", SWIG_From_int((int)(wxLIST_HITTEST_ONITEM)));
37597     }
37598     {
37599         PyDict_SetItemString(d,"LIST_NEXT_ABOVE", SWIG_From_int((int)(wxLIST_NEXT_ABOVE)));
37600     }
37601     {
37602         PyDict_SetItemString(d,"LIST_NEXT_ALL", SWIG_From_int((int)(wxLIST_NEXT_ALL)));
37603     }
37604     {
37605         PyDict_SetItemString(d,"LIST_NEXT_BELOW", SWIG_From_int((int)(wxLIST_NEXT_BELOW)));
37606     }
37607     {
37608         PyDict_SetItemString(d,"LIST_NEXT_LEFT", SWIG_From_int((int)(wxLIST_NEXT_LEFT)));
37609     }
37610     {
37611         PyDict_SetItemString(d,"LIST_NEXT_RIGHT", SWIG_From_int((int)(wxLIST_NEXT_RIGHT)));
37612     }
37613     {
37614         PyDict_SetItemString(d,"LIST_ALIGN_DEFAULT", SWIG_From_int((int)(wxLIST_ALIGN_DEFAULT)));
37615     }
37616     {
37617         PyDict_SetItemString(d,"LIST_ALIGN_LEFT", SWIG_From_int((int)(wxLIST_ALIGN_LEFT)));
37618     }
37619     {
37620         PyDict_SetItemString(d,"LIST_ALIGN_TOP", SWIG_From_int((int)(wxLIST_ALIGN_TOP)));
37621     }
37622     {
37623         PyDict_SetItemString(d,"LIST_ALIGN_SNAP_TO_GRID", SWIG_From_int((int)(wxLIST_ALIGN_SNAP_TO_GRID)));
37624     }
37625     {
37626         PyDict_SetItemString(d,"LIST_FORMAT_LEFT", SWIG_From_int((int)(wxLIST_FORMAT_LEFT)));
37627     }
37628     {
37629         PyDict_SetItemString(d,"LIST_FORMAT_RIGHT", SWIG_From_int((int)(wxLIST_FORMAT_RIGHT)));
37630     }
37631     {
37632         PyDict_SetItemString(d,"LIST_FORMAT_CENTRE", SWIG_From_int((int)(wxLIST_FORMAT_CENTRE)));
37633     }
37634     {
37635         PyDict_SetItemString(d,"LIST_FORMAT_CENTER", SWIG_From_int((int)(wxLIST_FORMAT_CENTER)));
37636     }
37637     {
37638         PyDict_SetItemString(d,"LIST_AUTOSIZE", SWIG_From_int((int)(wxLIST_AUTOSIZE)));
37639     }
37640     {
37641         PyDict_SetItemString(d,"LIST_AUTOSIZE_USEHEADER", SWIG_From_int((int)(wxLIST_AUTOSIZE_USEHEADER)));
37642     }
37643     {
37644         PyDict_SetItemString(d,"LIST_RECT_BOUNDS", SWIG_From_int((int)(wxLIST_RECT_BOUNDS)));
37645     }
37646     {
37647         PyDict_SetItemString(d,"LIST_RECT_ICON", SWIG_From_int((int)(wxLIST_RECT_ICON)));
37648     }
37649     {
37650         PyDict_SetItemString(d,"LIST_RECT_LABEL", SWIG_From_int((int)(wxLIST_RECT_LABEL)));
37651     }
37652     {
37653         PyDict_SetItemString(d,"LIST_FIND_UP", SWIG_From_int((int)(wxLIST_FIND_UP)));
37654     }
37655     {
37656         PyDict_SetItemString(d,"LIST_FIND_DOWN", SWIG_From_int((int)(wxLIST_FIND_DOWN)));
37657     }
37658     {
37659         PyDict_SetItemString(d,"LIST_FIND_LEFT", SWIG_From_int((int)(wxLIST_FIND_LEFT)));
37660     }
37661     {
37662         PyDict_SetItemString(d,"LIST_FIND_RIGHT", SWIG_From_int((int)(wxLIST_FIND_RIGHT)));
37663     }
37664     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_DRAG));
37665     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_RDRAG));
37666     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT));
37667     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_END_LABEL_EDIT));
37668     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ITEM));
37669     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS));
37670     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_GET_INFO", PyInt_FromLong(wxEVT_COMMAND_LIST_GET_INFO));
37671     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_SET_INFO", PyInt_FromLong(wxEVT_COMMAND_LIST_SET_INFO));
37672     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_SELECTED));
37673     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_DESELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_DESELECTED));
37674     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_LIST_KEY_DOWN));
37675     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_INSERT_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_INSERT_ITEM));
37676     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_CLICK));
37677     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK));
37678     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK));
37679     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_ACTIVATED));
37680     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_CACHE_HINT", PyInt_FromLong(wxEVT_COMMAND_LIST_CACHE_HINT));
37681     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK));
37682     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG));
37683     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_DRAGGING", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_DRAGGING));
37684     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_END_DRAG));
37685     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_FOCUSED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_FOCUSED));
37686
37687     // Map renamed classes back to their common name for OOR
37688     wxPyPtrTypeMap_Add("wxListCtrl", "wxPyListCtrl");
37689
37690     SWIG_addvarlink(SWIG_globals,(char*)"TreeCtrlNameStr",_wrap_TreeCtrlNameStr_get, _wrap_TreeCtrlNameStr_set);
37691     {
37692         PyDict_SetItemString(d,"TR_NO_BUTTONS", SWIG_From_int((int)(wxTR_NO_BUTTONS)));
37693     }
37694     {
37695         PyDict_SetItemString(d,"TR_HAS_BUTTONS", SWIG_From_int((int)(wxTR_HAS_BUTTONS)));
37696     }
37697     {
37698         PyDict_SetItemString(d,"TR_NO_LINES", SWIG_From_int((int)(wxTR_NO_LINES)));
37699     }
37700     {
37701         PyDict_SetItemString(d,"TR_LINES_AT_ROOT", SWIG_From_int((int)(wxTR_LINES_AT_ROOT)));
37702     }
37703     {
37704         PyDict_SetItemString(d,"TR_SINGLE", SWIG_From_int((int)(wxTR_SINGLE)));
37705     }
37706     {
37707         PyDict_SetItemString(d,"TR_MULTIPLE", SWIG_From_int((int)(wxTR_MULTIPLE)));
37708     }
37709     {
37710         PyDict_SetItemString(d,"TR_EXTENDED", SWIG_From_int((int)(wxTR_EXTENDED)));
37711     }
37712     {
37713         PyDict_SetItemString(d,"TR_HAS_VARIABLE_ROW_HEIGHT", SWIG_From_int((int)(wxTR_HAS_VARIABLE_ROW_HEIGHT)));
37714     }
37715     {
37716         PyDict_SetItemString(d,"TR_EDIT_LABELS", SWIG_From_int((int)(wxTR_EDIT_LABELS)));
37717     }
37718     {
37719         PyDict_SetItemString(d,"TR_HIDE_ROOT", SWIG_From_int((int)(wxTR_HIDE_ROOT)));
37720     }
37721     {
37722         PyDict_SetItemString(d,"TR_ROW_LINES", SWIG_From_int((int)(wxTR_ROW_LINES)));
37723     }
37724     {
37725         PyDict_SetItemString(d,"TR_FULL_ROW_HIGHLIGHT", SWIG_From_int((int)(wxTR_FULL_ROW_HIGHLIGHT)));
37726     }
37727     {
37728         PyDict_SetItemString(d,"TR_DEFAULT_STYLE", SWIG_From_int((int)(wxTR_DEFAULT_STYLE)));
37729     }
37730     {
37731         PyDict_SetItemString(d,"TR_TWIST_BUTTONS", SWIG_From_int((int)(wxTR_TWIST_BUTTONS)));
37732     }
37733     {
37734         PyDict_SetItemString(d,"TR_MAC_BUTTONS", SWIG_From_int((int)(wxTR_MAC_BUTTONS)));
37735     }
37736     {
37737         PyDict_SetItemString(d,"TR_AQUA_BUTTONS", SWIG_From_int((int)(wxTR_AQUA_BUTTONS)));
37738     }
37739     {
37740         PyDict_SetItemString(d,"TreeItemIcon_Normal", SWIG_From_int((int)(wxTreeItemIcon_Normal)));
37741     }
37742     {
37743         PyDict_SetItemString(d,"TreeItemIcon_Selected", SWIG_From_int((int)(wxTreeItemIcon_Selected)));
37744     }
37745     {
37746         PyDict_SetItemString(d,"TreeItemIcon_Expanded", SWIG_From_int((int)(wxTreeItemIcon_Expanded)));
37747     }
37748     {
37749         PyDict_SetItemString(d,"TreeItemIcon_SelectedExpanded", SWIG_From_int((int)(wxTreeItemIcon_SelectedExpanded)));
37750     }
37751     {
37752         PyDict_SetItemString(d,"TreeItemIcon_Max", SWIG_From_int((int)(wxTreeItemIcon_Max)));
37753     }
37754     {
37755         PyDict_SetItemString(d,"TREE_HITTEST_ABOVE", SWIG_From_int((int)(wxTREE_HITTEST_ABOVE)));
37756     }
37757     {
37758         PyDict_SetItemString(d,"TREE_HITTEST_BELOW", SWIG_From_int((int)(wxTREE_HITTEST_BELOW)));
37759     }
37760     {
37761         PyDict_SetItemString(d,"TREE_HITTEST_NOWHERE", SWIG_From_int((int)(wxTREE_HITTEST_NOWHERE)));
37762     }
37763     {
37764         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMBUTTON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMBUTTON)));
37765     }
37766     {
37767         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMICON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMICON)));
37768     }
37769     {
37770         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMINDENT", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMINDENT)));
37771     }
37772     {
37773         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMLABEL", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMLABEL)));
37774     }
37775     {
37776         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMRIGHT", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMRIGHT)));
37777     }
37778     {
37779         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMSTATEICON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMSTATEICON)));
37780     }
37781     {
37782         PyDict_SetItemString(d,"TREE_HITTEST_TOLEFT", SWIG_From_int((int)(wxTREE_HITTEST_TOLEFT)));
37783     }
37784     {
37785         PyDict_SetItemString(d,"TREE_HITTEST_TORIGHT", SWIG_From_int((int)(wxTREE_HITTEST_TORIGHT)));
37786     }
37787     {
37788         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMUPPERPART", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMUPPERPART)));
37789     }
37790     {
37791         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMLOWERPART", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMLOWERPART)));
37792     }
37793     {
37794         PyDict_SetItemString(d,"TREE_HITTEST_ONITEM", SWIG_From_int((int)(wxTREE_HITTEST_ONITEM)));
37795     }
37796     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_DRAG));
37797     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_RDRAG));
37798     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT));
37799     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_END_LABEL_EDIT));
37800     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_TREE_DELETE_ITEM));
37801     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_GET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_GET_INFO));
37802     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_SET_INFO));
37803     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDED));
37804     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDING));
37805     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSED));
37806     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSING));
37807     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGED", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGED));
37808     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGING", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGING));
37809     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_TREE_KEY_DOWN));
37810     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_ACTIVATED));
37811     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK));
37812     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK));
37813     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_END_DRAG));
37814     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK));
37815     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP));
37816     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MENU", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MENU));
37817
37818     // Map renamed classes back to their common name for OOR
37819     wxPyPtrTypeMap_Add("wxTreeItemData", "wxPyTreeItemData");
37820     wxPyPtrTypeMap_Add("wxTreeCtrl", "wxPyTreeCtrl");
37821
37822     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogDefaultFolderStr",_wrap_DirDialogDefaultFolderStr_get, _wrap_DirDialogDefaultFolderStr_set);
37823     {
37824         PyDict_SetItemString(d,"DIRCTRL_DIR_ONLY", SWIG_From_int((int)(wxDIRCTRL_DIR_ONLY)));
37825     }
37826     {
37827         PyDict_SetItemString(d,"DIRCTRL_SELECT_FIRST", SWIG_From_int((int)(wxDIRCTRL_SELECT_FIRST)));
37828     }
37829     {
37830         PyDict_SetItemString(d,"DIRCTRL_SHOW_FILTERS", SWIG_From_int((int)(wxDIRCTRL_SHOW_FILTERS)));
37831     }
37832     {
37833         PyDict_SetItemString(d,"DIRCTRL_3D_INTERNAL", SWIG_From_int((int)(wxDIRCTRL_3D_INTERNAL)));
37834     }
37835     {
37836         PyDict_SetItemString(d,"DIRCTRL_EDIT_LABELS", SWIG_From_int((int)(wxDIRCTRL_EDIT_LABELS)));
37837     }
37838     {
37839         PyDict_SetItemString(d,"FRAME_EX_CONTEXTHELP", SWIG_From_int((int)(wxFRAME_EX_CONTEXTHELP)));
37840     }
37841     {
37842         PyDict_SetItemString(d,"DIALOG_EX_CONTEXTHELP", SWIG_From_int((int)(wxDIALOG_EX_CONTEXTHELP)));
37843     }
37844     PyDict_SetItemString(d, "wxEVT_HELP", PyInt_FromLong(wxEVT_HELP));
37845     PyDict_SetItemString(d, "wxEVT_DETAILED_HELP", PyInt_FromLong(wxEVT_DETAILED_HELP));
37846
37847     wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage");
37848
37849 }
37850