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 wxPyNotebookNameStr(wxNotebookNameStr);
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(wxListCtrlNameStr);
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     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2194
2195     PYPRIVATE;
2196 };
2197
2198 IMPLEMENT_DYNAMIC_CLASS(wxPyControl, wxControl);
2199
2200 IMP_PYCALLBACK_VOID_INT4(wxPyControl, wxControl, DoMoveWindow);
2201 IMP_PYCALLBACK_VOID_INT5(wxPyControl, wxControl, DoSetSize);
2202 IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetClientSize);
2203 IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetVirtualSize);
2204
2205 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetSize);
2206 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetClientSize);
2207 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetPosition);
2208
2209 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetVirtualSize);
2210 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetBestSize);
2211
2212 IMP_PYCALLBACK__(wxPyControl, wxControl, InitDialog);
2213 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataFromWindow);
2214 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataToWindow);
2215 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, Validate);
2216
2217 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocus);
2218 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocusFromKeyboard);
2219 IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, GetMaxSize);
2220
2221 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, AddChild);
2222 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, RemoveChild);
2223
2224 IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, ShouldInheritColours);
2225 IMP_PYCALLBACK__COLOUR(wxPyControl, wxControl, ApplyParentThemeBackground);
2226 IMP_PYCALLBACK_VIZATTR_(wxPyControl, wxControl, GetDefaultAttributes);
2227
2228 IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, HasTransparentBackground);
2229
2230
2231
2232 static void wxHelpProvider_Destroy(wxHelpProvider *self){ delete self; }
2233
2234 #include <wx/generic/dragimgg.h>
2235
2236 #ifdef __cplusplus
2237 extern "C" {
2238 #endif
2239 static int _wrap_ButtonNameStr_set(PyObject *) {
2240     PyErr_SetString(PyExc_TypeError,"Variable ButtonNameStr is read-only.");
2241     return 1;
2242 }
2243
2244
2245 static PyObject *_wrap_ButtonNameStr_get(void) {
2246     PyObject *pyobj;
2247
2248     {
2249 #if wxUSE_UNICODE
2250         pyobj = PyUnicode_FromWideChar((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
2251 #else
2252         pyobj = PyString_FromStringAndSize((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
2253 #endif
2254     }
2255     return pyobj;
2256 }
2257
2258
2259 static PyObject *_wrap_new_Button(PyObject *, PyObject *args, PyObject *kwargs) {
2260     PyObject *resultobj;
2261     wxWindow *arg1 = (wxWindow *) 0 ;
2262     int arg2 = (int) -1 ;
2263     wxString const &arg3_defvalue = wxPyEmptyString ;
2264     wxString *arg3 = (wxString *) &arg3_defvalue ;
2265     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2266     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2267     wxSize const &arg5_defvalue = wxDefaultSize ;
2268     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2269     long arg6 = (long) 0 ;
2270     wxValidator const &arg7_defvalue = wxDefaultValidator ;
2271     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
2272     wxString const &arg8_defvalue = wxPyButtonNameStr ;
2273     wxString *arg8 = (wxString *) &arg8_defvalue ;
2274     wxButton *result;
2275     bool temp3 = false ;
2276     wxPoint temp4 ;
2277     wxSize temp5 ;
2278     bool temp8 = false ;
2279     PyObject * obj0 = 0 ;
2280     PyObject * obj1 = 0 ;
2281     PyObject * obj2 = 0 ;
2282     PyObject * obj3 = 0 ;
2283     PyObject * obj4 = 0 ;
2284     PyObject * obj5 = 0 ;
2285     PyObject * obj6 = 0 ;
2286     PyObject * obj7 = 0 ;
2287     char *kwnames[] = {
2288         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2289     };
2290
2291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Button",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2292     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2293     if (SWIG_arg_fail(1)) SWIG_fail;
2294     if (obj1) {
2295         {
2296             arg2 = (int)(SWIG_As_int(obj1));
2297             if (SWIG_arg_fail(2)) SWIG_fail;
2298         }
2299     }
2300     if (obj2) {
2301         {
2302             arg3 = wxString_in_helper(obj2);
2303             if (arg3 == NULL) SWIG_fail;
2304             temp3 = true;
2305         }
2306     }
2307     if (obj3) {
2308         {
2309             arg4 = &temp4;
2310             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2311         }
2312     }
2313     if (obj4) {
2314         {
2315             arg5 = &temp5;
2316             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2317         }
2318     }
2319     if (obj5) {
2320         {
2321             arg6 = (long)(SWIG_As_long(obj5));
2322             if (SWIG_arg_fail(6)) SWIG_fail;
2323         }
2324     }
2325     if (obj6) {
2326         {
2327             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2328             if (SWIG_arg_fail(7)) SWIG_fail;
2329             if (arg7 == NULL) {
2330                 SWIG_null_ref("wxValidator");
2331             }
2332             if (SWIG_arg_fail(7)) SWIG_fail;
2333         }
2334     }
2335     if (obj7) {
2336         {
2337             arg8 = wxString_in_helper(obj7);
2338             if (arg8 == NULL) SWIG_fail;
2339             temp8 = true;
2340         }
2341     }
2342     {
2343         if (!wxPyCheckForApp()) SWIG_fail;
2344         PyThreadState* __tstate = wxPyBeginAllowThreads();
2345         result = (wxButton *)new wxButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
2346
2347         wxPyEndAllowThreads(__tstate);
2348         if (PyErr_Occurred()) SWIG_fail;
2349     }
2350     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxButton, 1);
2351     {
2352         if (temp3)
2353         delete arg3;
2354     }
2355     {
2356         if (temp8)
2357         delete arg8;
2358     }
2359     return resultobj;
2360     fail:
2361     {
2362         if (temp3)
2363         delete arg3;
2364     }
2365     {
2366         if (temp8)
2367         delete arg8;
2368     }
2369     return NULL;
2370 }
2371
2372
2373 static PyObject *_wrap_new_PreButton(PyObject *, PyObject *args, PyObject *kwargs) {
2374     PyObject *resultobj;
2375     wxButton *result;
2376     char *kwnames[] = {
2377         NULL
2378     };
2379
2380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreButton",kwnames)) goto fail;
2381     {
2382         if (!wxPyCheckForApp()) SWIG_fail;
2383         PyThreadState* __tstate = wxPyBeginAllowThreads();
2384         result = (wxButton *)new wxButton();
2385
2386         wxPyEndAllowThreads(__tstate);
2387         if (PyErr_Occurred()) SWIG_fail;
2388     }
2389     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxButton, 1);
2390     return resultobj;
2391     fail:
2392     return NULL;
2393 }
2394
2395
2396 static PyObject *_wrap_Button_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2397     PyObject *resultobj;
2398     wxButton *arg1 = (wxButton *) 0 ;
2399     wxWindow *arg2 = (wxWindow *) 0 ;
2400     int arg3 = (int) -1 ;
2401     wxString const &arg4_defvalue = wxPyEmptyString ;
2402     wxString *arg4 = (wxString *) &arg4_defvalue ;
2403     wxPoint const &arg5_defvalue = wxDefaultPosition ;
2404     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
2405     wxSize const &arg6_defvalue = wxDefaultSize ;
2406     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
2407     long arg7 = (long) 0 ;
2408     wxValidator const &arg8_defvalue = wxDefaultValidator ;
2409     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
2410     wxString const &arg9_defvalue = wxPyButtonNameStr ;
2411     wxString *arg9 = (wxString *) &arg9_defvalue ;
2412     bool result;
2413     bool temp4 = false ;
2414     wxPoint temp5 ;
2415     wxSize temp6 ;
2416     bool temp9 = false ;
2417     PyObject * obj0 = 0 ;
2418     PyObject * obj1 = 0 ;
2419     PyObject * obj2 = 0 ;
2420     PyObject * obj3 = 0 ;
2421     PyObject * obj4 = 0 ;
2422     PyObject * obj5 = 0 ;
2423     PyObject * obj6 = 0 ;
2424     PyObject * obj7 = 0 ;
2425     PyObject * obj8 = 0 ;
2426     char *kwnames[] = {
2427         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2428     };
2429
2430     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Button_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2431     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
2432     if (SWIG_arg_fail(1)) SWIG_fail;
2433     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2434     if (SWIG_arg_fail(2)) SWIG_fail;
2435     if (obj2) {
2436         {
2437             arg3 = (int)(SWIG_As_int(obj2));
2438             if (SWIG_arg_fail(3)) SWIG_fail;
2439         }
2440     }
2441     if (obj3) {
2442         {
2443             arg4 = wxString_in_helper(obj3);
2444             if (arg4 == NULL) SWIG_fail;
2445             temp4 = true;
2446         }
2447     }
2448     if (obj4) {
2449         {
2450             arg5 = &temp5;
2451             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
2452         }
2453     }
2454     if (obj5) {
2455         {
2456             arg6 = &temp6;
2457             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
2458         }
2459     }
2460     if (obj6) {
2461         {
2462             arg7 = (long)(SWIG_As_long(obj6));
2463             if (SWIG_arg_fail(7)) SWIG_fail;
2464         }
2465     }
2466     if (obj7) {
2467         {
2468             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2469             if (SWIG_arg_fail(8)) SWIG_fail;
2470             if (arg8 == NULL) {
2471                 SWIG_null_ref("wxValidator");
2472             }
2473             if (SWIG_arg_fail(8)) SWIG_fail;
2474         }
2475     }
2476     if (obj8) {
2477         {
2478             arg9 = wxString_in_helper(obj8);
2479             if (arg9 == NULL) SWIG_fail;
2480             temp9 = true;
2481         }
2482     }
2483     {
2484         PyThreadState* __tstate = wxPyBeginAllowThreads();
2485         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
2486
2487         wxPyEndAllowThreads(__tstate);
2488         if (PyErr_Occurred()) SWIG_fail;
2489     }
2490     {
2491         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2492     }
2493     {
2494         if (temp4)
2495         delete arg4;
2496     }
2497     {
2498         if (temp9)
2499         delete arg9;
2500     }
2501     return resultobj;
2502     fail:
2503     {
2504         if (temp4)
2505         delete arg4;
2506     }
2507     {
2508         if (temp9)
2509         delete arg9;
2510     }
2511     return NULL;
2512 }
2513
2514
2515 static PyObject *_wrap_Button_SetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
2516     PyObject *resultobj;
2517     wxButton *arg1 = (wxButton *) 0 ;
2518     PyObject * obj0 = 0 ;
2519     char *kwnames[] = {
2520         (char *) "self", NULL
2521     };
2522
2523     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Button_SetDefault",kwnames,&obj0)) goto fail;
2524     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
2525     if (SWIG_arg_fail(1)) SWIG_fail;
2526     {
2527         PyThreadState* __tstate = wxPyBeginAllowThreads();
2528         (arg1)->SetDefault();
2529
2530         wxPyEndAllowThreads(__tstate);
2531         if (PyErr_Occurred()) SWIG_fail;
2532     }
2533     Py_INCREF(Py_None); resultobj = Py_None;
2534     return resultobj;
2535     fail:
2536     return NULL;
2537 }
2538
2539
2540 static PyObject *_wrap_Button_GetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
2541     PyObject *resultobj;
2542     wxSize result;
2543     char *kwnames[] = {
2544         NULL
2545     };
2546
2547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Button_GetDefaultSize",kwnames)) goto fail;
2548     {
2549         PyThreadState* __tstate = wxPyBeginAllowThreads();
2550         result = wxButton::GetDefaultSize();
2551
2552         wxPyEndAllowThreads(__tstate);
2553         if (PyErr_Occurred()) SWIG_fail;
2554     }
2555     {
2556         wxSize * resultptr;
2557         resultptr = new wxSize((wxSize &)(result));
2558         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
2559     }
2560     return resultobj;
2561     fail:
2562     return NULL;
2563 }
2564
2565
2566 static PyObject *_wrap_Button_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
2567     PyObject *resultobj;
2568     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
2569     wxVisualAttributes result;
2570     PyObject * obj0 = 0 ;
2571     char *kwnames[] = {
2572         (char *) "variant", NULL
2573     };
2574
2575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Button_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
2576     if (obj0) {
2577         {
2578             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
2579             if (SWIG_arg_fail(1)) SWIG_fail;
2580         }
2581     }
2582     {
2583         if (!wxPyCheckForApp()) SWIG_fail;
2584         PyThreadState* __tstate = wxPyBeginAllowThreads();
2585         result = wxButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
2586
2587         wxPyEndAllowThreads(__tstate);
2588         if (PyErr_Occurred()) SWIG_fail;
2589     }
2590     {
2591         wxVisualAttributes * resultptr;
2592         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
2593         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
2594     }
2595     return resultobj;
2596     fail:
2597     return NULL;
2598 }
2599
2600
2601 static PyObject * Button_swigregister(PyObject *, PyObject *args) {
2602     PyObject *obj;
2603     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2604     SWIG_TypeClientData(SWIGTYPE_p_wxButton, obj);
2605     Py_INCREF(obj);
2606     return Py_BuildValue((char *)"");
2607 }
2608 static PyObject *_wrap_new_BitmapButton(PyObject *, PyObject *args, PyObject *kwargs) {
2609     PyObject *resultobj;
2610     wxWindow *arg1 = (wxWindow *) 0 ;
2611     int arg2 = (int) -1 ;
2612     wxBitmap const &arg3_defvalue = wxNullBitmap ;
2613     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
2614     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2615     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2616     wxSize const &arg5_defvalue = wxDefaultSize ;
2617     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2618     long arg6 = (long) wxBU_AUTODRAW ;
2619     wxValidator const &arg7_defvalue = wxDefaultValidator ;
2620     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
2621     wxString const &arg8_defvalue = wxPyButtonNameStr ;
2622     wxString *arg8 = (wxString *) &arg8_defvalue ;
2623     wxBitmapButton *result;
2624     wxPoint temp4 ;
2625     wxSize temp5 ;
2626     bool temp8 = false ;
2627     PyObject * obj0 = 0 ;
2628     PyObject * obj1 = 0 ;
2629     PyObject * obj2 = 0 ;
2630     PyObject * obj3 = 0 ;
2631     PyObject * obj4 = 0 ;
2632     PyObject * obj5 = 0 ;
2633     PyObject * obj6 = 0 ;
2634     PyObject * obj7 = 0 ;
2635     char *kwnames[] = {
2636         (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2637     };
2638
2639     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_BitmapButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
2640     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2641     if (SWIG_arg_fail(1)) SWIG_fail;
2642     if (obj1) {
2643         {
2644             arg2 = (int)(SWIG_As_int(obj1));
2645             if (SWIG_arg_fail(2)) SWIG_fail;
2646         }
2647     }
2648     if (obj2) {
2649         {
2650             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2651             if (SWIG_arg_fail(3)) SWIG_fail;
2652             if (arg3 == NULL) {
2653                 SWIG_null_ref("wxBitmap");
2654             }
2655             if (SWIG_arg_fail(3)) SWIG_fail;
2656         }
2657     }
2658     if (obj3) {
2659         {
2660             arg4 = &temp4;
2661             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2662         }
2663     }
2664     if (obj4) {
2665         {
2666             arg5 = &temp5;
2667             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2668         }
2669     }
2670     if (obj5) {
2671         {
2672             arg6 = (long)(SWIG_As_long(obj5));
2673             if (SWIG_arg_fail(6)) SWIG_fail;
2674         }
2675     }
2676     if (obj6) {
2677         {
2678             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2679             if (SWIG_arg_fail(7)) SWIG_fail;
2680             if (arg7 == NULL) {
2681                 SWIG_null_ref("wxValidator");
2682             }
2683             if (SWIG_arg_fail(7)) SWIG_fail;
2684         }
2685     }
2686     if (obj7) {
2687         {
2688             arg8 = wxString_in_helper(obj7);
2689             if (arg8 == NULL) SWIG_fail;
2690             temp8 = true;
2691         }
2692     }
2693     {
2694         if (!wxPyCheckForApp()) SWIG_fail;
2695         PyThreadState* __tstate = wxPyBeginAllowThreads();
2696         result = (wxBitmapButton *)new wxBitmapButton(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
2697
2698         wxPyEndAllowThreads(__tstate);
2699         if (PyErr_Occurred()) SWIG_fail;
2700     }
2701     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapButton, 1);
2702     {
2703         if (temp8)
2704         delete arg8;
2705     }
2706     return resultobj;
2707     fail:
2708     {
2709         if (temp8)
2710         delete arg8;
2711     }
2712     return NULL;
2713 }
2714
2715
2716 static PyObject *_wrap_new_PreBitmapButton(PyObject *, PyObject *args, PyObject *kwargs) {
2717     PyObject *resultobj;
2718     wxBitmapButton *result;
2719     char *kwnames[] = {
2720         NULL
2721     };
2722
2723     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreBitmapButton",kwnames)) goto fail;
2724     {
2725         if (!wxPyCheckForApp()) SWIG_fail;
2726         PyThreadState* __tstate = wxPyBeginAllowThreads();
2727         result = (wxBitmapButton *)new wxBitmapButton();
2728
2729         wxPyEndAllowThreads(__tstate);
2730         if (PyErr_Occurred()) SWIG_fail;
2731     }
2732     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapButton, 1);
2733     return resultobj;
2734     fail:
2735     return NULL;
2736 }
2737
2738
2739 static PyObject *_wrap_BitmapButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2740     PyObject *resultobj;
2741     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2742     wxWindow *arg2 = (wxWindow *) 0 ;
2743     int arg3 = (int) -1 ;
2744     wxBitmap const &arg4_defvalue = wxNullBitmap ;
2745     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
2746     wxPoint const &arg5_defvalue = wxDefaultPosition ;
2747     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
2748     wxSize const &arg6_defvalue = wxDefaultSize ;
2749     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
2750     long arg7 = (long) wxBU_AUTODRAW ;
2751     wxValidator const &arg8_defvalue = wxDefaultValidator ;
2752     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
2753     wxString const &arg9_defvalue = wxPyButtonNameStr ;
2754     wxString *arg9 = (wxString *) &arg9_defvalue ;
2755     bool result;
2756     wxPoint temp5 ;
2757     wxSize temp6 ;
2758     bool temp9 = false ;
2759     PyObject * obj0 = 0 ;
2760     PyObject * obj1 = 0 ;
2761     PyObject * obj2 = 0 ;
2762     PyObject * obj3 = 0 ;
2763     PyObject * obj4 = 0 ;
2764     PyObject * obj5 = 0 ;
2765     PyObject * obj6 = 0 ;
2766     PyObject * obj7 = 0 ;
2767     PyObject * obj8 = 0 ;
2768     char *kwnames[] = {
2769         (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
2770     };
2771
2772     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:BitmapButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2773     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2774     if (SWIG_arg_fail(1)) SWIG_fail;
2775     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2776     if (SWIG_arg_fail(2)) SWIG_fail;
2777     if (obj2) {
2778         {
2779             arg3 = (int)(SWIG_As_int(obj2));
2780             if (SWIG_arg_fail(3)) SWIG_fail;
2781         }
2782     }
2783     if (obj3) {
2784         {
2785             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2786             if (SWIG_arg_fail(4)) SWIG_fail;
2787             if (arg4 == NULL) {
2788                 SWIG_null_ref("wxBitmap");
2789             }
2790             if (SWIG_arg_fail(4)) SWIG_fail;
2791         }
2792     }
2793     if (obj4) {
2794         {
2795             arg5 = &temp5;
2796             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
2797         }
2798     }
2799     if (obj5) {
2800         {
2801             arg6 = &temp6;
2802             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
2803         }
2804     }
2805     if (obj6) {
2806         {
2807             arg7 = (long)(SWIG_As_long(obj6));
2808             if (SWIG_arg_fail(7)) SWIG_fail;
2809         }
2810     }
2811     if (obj7) {
2812         {
2813             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
2814             if (SWIG_arg_fail(8)) SWIG_fail;
2815             if (arg8 == NULL) {
2816                 SWIG_null_ref("wxValidator");
2817             }
2818             if (SWIG_arg_fail(8)) SWIG_fail;
2819         }
2820     }
2821     if (obj8) {
2822         {
2823             arg9 = wxString_in_helper(obj8);
2824             if (arg9 == NULL) SWIG_fail;
2825             temp9 = true;
2826         }
2827     }
2828     {
2829         PyThreadState* __tstate = wxPyBeginAllowThreads();
2830         result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
2831
2832         wxPyEndAllowThreads(__tstate);
2833         if (PyErr_Occurred()) SWIG_fail;
2834     }
2835     {
2836         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2837     }
2838     {
2839         if (temp9)
2840         delete arg9;
2841     }
2842     return resultobj;
2843     fail:
2844     {
2845         if (temp9)
2846         delete arg9;
2847     }
2848     return NULL;
2849 }
2850
2851
2852 static PyObject *_wrap_BitmapButton_GetBitmapLabel(PyObject *, PyObject *args, PyObject *kwargs) {
2853     PyObject *resultobj;
2854     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2855     wxBitmap result;
2856     PyObject * obj0 = 0 ;
2857     char *kwnames[] = {
2858         (char *) "self", NULL
2859     };
2860
2861     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapLabel",kwnames,&obj0)) goto fail;
2862     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2863     if (SWIG_arg_fail(1)) SWIG_fail;
2864     {
2865         PyThreadState* __tstate = wxPyBeginAllowThreads();
2866         result = (arg1)->GetBitmapLabel();
2867
2868         wxPyEndAllowThreads(__tstate);
2869         if (PyErr_Occurred()) SWIG_fail;
2870     }
2871     {
2872         wxBitmap * resultptr;
2873         resultptr = new wxBitmap((wxBitmap &)(result));
2874         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2875     }
2876     return resultobj;
2877     fail:
2878     return NULL;
2879 }
2880
2881
2882 static PyObject *_wrap_BitmapButton_GetBitmapDisabled(PyObject *, PyObject *args, PyObject *kwargs) {
2883     PyObject *resultobj;
2884     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2885     wxBitmap result;
2886     PyObject * obj0 = 0 ;
2887     char *kwnames[] = {
2888         (char *) "self", NULL
2889     };
2890
2891     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapDisabled",kwnames,&obj0)) goto fail;
2892     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2893     if (SWIG_arg_fail(1)) SWIG_fail;
2894     {
2895         PyThreadState* __tstate = wxPyBeginAllowThreads();
2896         result = (arg1)->GetBitmapDisabled();
2897
2898         wxPyEndAllowThreads(__tstate);
2899         if (PyErr_Occurred()) SWIG_fail;
2900     }
2901     {
2902         wxBitmap * resultptr;
2903         resultptr = new wxBitmap((wxBitmap &)(result));
2904         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2905     }
2906     return resultobj;
2907     fail:
2908     return NULL;
2909 }
2910
2911
2912 static PyObject *_wrap_BitmapButton_GetBitmapFocus(PyObject *, PyObject *args, PyObject *kwargs) {
2913     PyObject *resultobj;
2914     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2915     wxBitmap result;
2916     PyObject * obj0 = 0 ;
2917     char *kwnames[] = {
2918         (char *) "self", NULL
2919     };
2920
2921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapFocus",kwnames,&obj0)) goto fail;
2922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2923     if (SWIG_arg_fail(1)) SWIG_fail;
2924     {
2925         PyThreadState* __tstate = wxPyBeginAllowThreads();
2926         result = (arg1)->GetBitmapFocus();
2927
2928         wxPyEndAllowThreads(__tstate);
2929         if (PyErr_Occurred()) SWIG_fail;
2930     }
2931     {
2932         wxBitmap * resultptr;
2933         resultptr = new wxBitmap((wxBitmap &)(result));
2934         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2935     }
2936     return resultobj;
2937     fail:
2938     return NULL;
2939 }
2940
2941
2942 static PyObject *_wrap_BitmapButton_GetBitmapSelected(PyObject *, PyObject *args, PyObject *kwargs) {
2943     PyObject *resultobj;
2944     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2945     wxBitmap result;
2946     PyObject * obj0 = 0 ;
2947     char *kwnames[] = {
2948         (char *) "self", NULL
2949     };
2950
2951     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetBitmapSelected",kwnames,&obj0)) goto fail;
2952     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2953     if (SWIG_arg_fail(1)) SWIG_fail;
2954     {
2955         PyThreadState* __tstate = wxPyBeginAllowThreads();
2956         result = (arg1)->GetBitmapSelected();
2957
2958         wxPyEndAllowThreads(__tstate);
2959         if (PyErr_Occurred()) SWIG_fail;
2960     }
2961     {
2962         wxBitmap * resultptr;
2963         resultptr = new wxBitmap((wxBitmap &)(result));
2964         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
2965     }
2966     return resultobj;
2967     fail:
2968     return NULL;
2969 }
2970
2971
2972 static PyObject *_wrap_BitmapButton_SetBitmapDisabled(PyObject *, PyObject *args, PyObject *kwargs) {
2973     PyObject *resultobj;
2974     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
2975     wxBitmap *arg2 = 0 ;
2976     PyObject * obj0 = 0 ;
2977     PyObject * obj1 = 0 ;
2978     char *kwnames[] = {
2979         (char *) "self",(char *) "bitmap", NULL
2980     };
2981
2982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapDisabled",kwnames,&obj0,&obj1)) goto fail;
2983     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
2984     if (SWIG_arg_fail(1)) SWIG_fail;
2985     {
2986         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
2987         if (SWIG_arg_fail(2)) SWIG_fail;
2988         if (arg2 == NULL) {
2989             SWIG_null_ref("wxBitmap");
2990         }
2991         if (SWIG_arg_fail(2)) SWIG_fail;
2992     }
2993     {
2994         PyThreadState* __tstate = wxPyBeginAllowThreads();
2995         (arg1)->SetBitmapDisabled((wxBitmap const &)*arg2);
2996
2997         wxPyEndAllowThreads(__tstate);
2998         if (PyErr_Occurred()) SWIG_fail;
2999     }
3000     Py_INCREF(Py_None); resultobj = Py_None;
3001     return resultobj;
3002     fail:
3003     return NULL;
3004 }
3005
3006
3007 static PyObject *_wrap_BitmapButton_SetBitmapFocus(PyObject *, PyObject *args, PyObject *kwargs) {
3008     PyObject *resultobj;
3009     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3010     wxBitmap *arg2 = 0 ;
3011     PyObject * obj0 = 0 ;
3012     PyObject * obj1 = 0 ;
3013     char *kwnames[] = {
3014         (char *) "self",(char *) "bitmap", NULL
3015     };
3016
3017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapFocus",kwnames,&obj0,&obj1)) goto fail;
3018     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3019     if (SWIG_arg_fail(1)) SWIG_fail;
3020     {
3021         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3022         if (SWIG_arg_fail(2)) SWIG_fail;
3023         if (arg2 == NULL) {
3024             SWIG_null_ref("wxBitmap");
3025         }
3026         if (SWIG_arg_fail(2)) SWIG_fail;
3027     }
3028     {
3029         PyThreadState* __tstate = wxPyBeginAllowThreads();
3030         (arg1)->SetBitmapFocus((wxBitmap const &)*arg2);
3031
3032         wxPyEndAllowThreads(__tstate);
3033         if (PyErr_Occurred()) SWIG_fail;
3034     }
3035     Py_INCREF(Py_None); resultobj = Py_None;
3036     return resultobj;
3037     fail:
3038     return NULL;
3039 }
3040
3041
3042 static PyObject *_wrap_BitmapButton_SetBitmapSelected(PyObject *, PyObject *args, PyObject *kwargs) {
3043     PyObject *resultobj;
3044     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3045     wxBitmap *arg2 = 0 ;
3046     PyObject * obj0 = 0 ;
3047     PyObject * obj1 = 0 ;
3048     char *kwnames[] = {
3049         (char *) "self",(char *) "bitmap", NULL
3050     };
3051
3052     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapSelected",kwnames,&obj0,&obj1)) goto fail;
3053     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3054     if (SWIG_arg_fail(1)) SWIG_fail;
3055     {
3056         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3057         if (SWIG_arg_fail(2)) SWIG_fail;
3058         if (arg2 == NULL) {
3059             SWIG_null_ref("wxBitmap");
3060         }
3061         if (SWIG_arg_fail(2)) SWIG_fail;
3062     }
3063     {
3064         PyThreadState* __tstate = wxPyBeginAllowThreads();
3065         (arg1)->SetBitmapSelected((wxBitmap const &)*arg2);
3066
3067         wxPyEndAllowThreads(__tstate);
3068         if (PyErr_Occurred()) SWIG_fail;
3069     }
3070     Py_INCREF(Py_None); resultobj = Py_None;
3071     return resultobj;
3072     fail:
3073     return NULL;
3074 }
3075
3076
3077 static PyObject *_wrap_BitmapButton_SetBitmapLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3078     PyObject *resultobj;
3079     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3080     wxBitmap *arg2 = 0 ;
3081     PyObject * obj0 = 0 ;
3082     PyObject * obj1 = 0 ;
3083     char *kwnames[] = {
3084         (char *) "self",(char *) "bitmap", NULL
3085     };
3086
3087     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapButton_SetBitmapLabel",kwnames,&obj0,&obj1)) goto fail;
3088     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3089     if (SWIG_arg_fail(1)) SWIG_fail;
3090     {
3091         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3092         if (SWIG_arg_fail(2)) SWIG_fail;
3093         if (arg2 == NULL) {
3094             SWIG_null_ref("wxBitmap");
3095         }
3096         if (SWIG_arg_fail(2)) SWIG_fail;
3097     }
3098     {
3099         PyThreadState* __tstate = wxPyBeginAllowThreads();
3100         (arg1)->SetBitmapLabel((wxBitmap const &)*arg2);
3101
3102         wxPyEndAllowThreads(__tstate);
3103         if (PyErr_Occurred()) SWIG_fail;
3104     }
3105     Py_INCREF(Py_None); resultobj = Py_None;
3106     return resultobj;
3107     fail:
3108     return NULL;
3109 }
3110
3111
3112 static PyObject *_wrap_BitmapButton_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
3113     PyObject *resultobj;
3114     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3115     int arg2 ;
3116     int arg3 ;
3117     PyObject * obj0 = 0 ;
3118     PyObject * obj1 = 0 ;
3119     PyObject * obj2 = 0 ;
3120     char *kwnames[] = {
3121         (char *) "self",(char *) "x",(char *) "y", NULL
3122     };
3123
3124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BitmapButton_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
3125     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3126     if (SWIG_arg_fail(1)) SWIG_fail;
3127     {
3128         arg2 = (int)(SWIG_As_int(obj1));
3129         if (SWIG_arg_fail(2)) SWIG_fail;
3130     }
3131     {
3132         arg3 = (int)(SWIG_As_int(obj2));
3133         if (SWIG_arg_fail(3)) SWIG_fail;
3134     }
3135     {
3136         PyThreadState* __tstate = wxPyBeginAllowThreads();
3137         (arg1)->SetMargins(arg2,arg3);
3138
3139         wxPyEndAllowThreads(__tstate);
3140         if (PyErr_Occurred()) SWIG_fail;
3141     }
3142     Py_INCREF(Py_None); resultobj = Py_None;
3143     return resultobj;
3144     fail:
3145     return NULL;
3146 }
3147
3148
3149 static PyObject *_wrap_BitmapButton_GetMarginX(PyObject *, PyObject *args, PyObject *kwargs) {
3150     PyObject *resultobj;
3151     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3152     int result;
3153     PyObject * obj0 = 0 ;
3154     char *kwnames[] = {
3155         (char *) "self", NULL
3156     };
3157
3158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetMarginX",kwnames,&obj0)) goto fail;
3159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3160     if (SWIG_arg_fail(1)) SWIG_fail;
3161     {
3162         PyThreadState* __tstate = wxPyBeginAllowThreads();
3163         result = (int)((wxBitmapButton const *)arg1)->GetMarginX();
3164
3165         wxPyEndAllowThreads(__tstate);
3166         if (PyErr_Occurred()) SWIG_fail;
3167     }
3168     {
3169         resultobj = SWIG_From_int((int)(result));
3170     }
3171     return resultobj;
3172     fail:
3173     return NULL;
3174 }
3175
3176
3177 static PyObject *_wrap_BitmapButton_GetMarginY(PyObject *, PyObject *args, PyObject *kwargs) {
3178     PyObject *resultobj;
3179     wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
3180     int result;
3181     PyObject * obj0 = 0 ;
3182     char *kwnames[] = {
3183         (char *) "self", NULL
3184     };
3185
3186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapButton_GetMarginY",kwnames,&obj0)) goto fail;
3187     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_EXCEPTION | 0);
3188     if (SWIG_arg_fail(1)) SWIG_fail;
3189     {
3190         PyThreadState* __tstate = wxPyBeginAllowThreads();
3191         result = (int)((wxBitmapButton const *)arg1)->GetMarginY();
3192
3193         wxPyEndAllowThreads(__tstate);
3194         if (PyErr_Occurred()) SWIG_fail;
3195     }
3196     {
3197         resultobj = SWIG_From_int((int)(result));
3198     }
3199     return resultobj;
3200     fail:
3201     return NULL;
3202 }
3203
3204
3205 static PyObject * BitmapButton_swigregister(PyObject *, PyObject *args) {
3206     PyObject *obj;
3207     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3208     SWIG_TypeClientData(SWIGTYPE_p_wxBitmapButton, obj);
3209     Py_INCREF(obj);
3210     return Py_BuildValue((char *)"");
3211 }
3212 static int _wrap_CheckBoxNameStr_set(PyObject *) {
3213     PyErr_SetString(PyExc_TypeError,"Variable CheckBoxNameStr is read-only.");
3214     return 1;
3215 }
3216
3217
3218 static PyObject *_wrap_CheckBoxNameStr_get(void) {
3219     PyObject *pyobj;
3220
3221     {
3222 #if wxUSE_UNICODE
3223         pyobj = PyUnicode_FromWideChar((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
3224 #else
3225         pyobj = PyString_FromStringAndSize((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
3226 #endif
3227     }
3228     return pyobj;
3229 }
3230
3231
3232 static PyObject *_wrap_new_CheckBox(PyObject *, PyObject *args, PyObject *kwargs) {
3233     PyObject *resultobj;
3234     wxWindow *arg1 = (wxWindow *) 0 ;
3235     int arg2 = (int) -1 ;
3236     wxString const &arg3_defvalue = wxPyEmptyString ;
3237     wxString *arg3 = (wxString *) &arg3_defvalue ;
3238     wxPoint const &arg4_defvalue = wxDefaultPosition ;
3239     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
3240     wxSize const &arg5_defvalue = wxDefaultSize ;
3241     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
3242     long arg6 = (long) 0 ;
3243     wxValidator const &arg7_defvalue = wxDefaultValidator ;
3244     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
3245     wxString const &arg8_defvalue = wxPyCheckBoxNameStr ;
3246     wxString *arg8 = (wxString *) &arg8_defvalue ;
3247     wxCheckBox *result;
3248     bool temp3 = false ;
3249     wxPoint temp4 ;
3250     wxSize temp5 ;
3251     bool temp8 = false ;
3252     PyObject * obj0 = 0 ;
3253     PyObject * obj1 = 0 ;
3254     PyObject * obj2 = 0 ;
3255     PyObject * obj3 = 0 ;
3256     PyObject * obj4 = 0 ;
3257     PyObject * obj5 = 0 ;
3258     PyObject * obj6 = 0 ;
3259     PyObject * obj7 = 0 ;
3260     char *kwnames[] = {
3261         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
3262     };
3263
3264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3266     if (SWIG_arg_fail(1)) SWIG_fail;
3267     if (obj1) {
3268         {
3269             arg2 = (int)(SWIG_As_int(obj1));
3270             if (SWIG_arg_fail(2)) SWIG_fail;
3271         }
3272     }
3273     if (obj2) {
3274         {
3275             arg3 = wxString_in_helper(obj2);
3276             if (arg3 == NULL) SWIG_fail;
3277             temp3 = true;
3278         }
3279     }
3280     if (obj3) {
3281         {
3282             arg4 = &temp4;
3283             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3284         }
3285     }
3286     if (obj4) {
3287         {
3288             arg5 = &temp5;
3289             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3290         }
3291     }
3292     if (obj5) {
3293         {
3294             arg6 = (long)(SWIG_As_long(obj5));
3295             if (SWIG_arg_fail(6)) SWIG_fail;
3296         }
3297     }
3298     if (obj6) {
3299         {
3300             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3301             if (SWIG_arg_fail(7)) SWIG_fail;
3302             if (arg7 == NULL) {
3303                 SWIG_null_ref("wxValidator");
3304             }
3305             if (SWIG_arg_fail(7)) SWIG_fail;
3306         }
3307     }
3308     if (obj7) {
3309         {
3310             arg8 = wxString_in_helper(obj7);
3311             if (arg8 == NULL) SWIG_fail;
3312             temp8 = true;
3313         }
3314     }
3315     {
3316         if (!wxPyCheckForApp()) SWIG_fail;
3317         PyThreadState* __tstate = wxPyBeginAllowThreads();
3318         result = (wxCheckBox *)new wxCheckBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
3319
3320         wxPyEndAllowThreads(__tstate);
3321         if (PyErr_Occurred()) SWIG_fail;
3322     }
3323     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckBox, 1);
3324     {
3325         if (temp3)
3326         delete arg3;
3327     }
3328     {
3329         if (temp8)
3330         delete arg8;
3331     }
3332     return resultobj;
3333     fail:
3334     {
3335         if (temp3)
3336         delete arg3;
3337     }
3338     {
3339         if (temp8)
3340         delete arg8;
3341     }
3342     return NULL;
3343 }
3344
3345
3346 static PyObject *_wrap_new_PreCheckBox(PyObject *, PyObject *args, PyObject *kwargs) {
3347     PyObject *resultobj;
3348     wxCheckBox *result;
3349     char *kwnames[] = {
3350         NULL
3351     };
3352
3353     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreCheckBox",kwnames)) goto fail;
3354     {
3355         if (!wxPyCheckForApp()) SWIG_fail;
3356         PyThreadState* __tstate = wxPyBeginAllowThreads();
3357         result = (wxCheckBox *)new wxCheckBox();
3358
3359         wxPyEndAllowThreads(__tstate);
3360         if (PyErr_Occurred()) SWIG_fail;
3361     }
3362     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckBox, 1);
3363     return resultobj;
3364     fail:
3365     return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_CheckBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3370     PyObject *resultobj;
3371     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3372     wxWindow *arg2 = (wxWindow *) 0 ;
3373     int arg3 = (int) -1 ;
3374     wxString const &arg4_defvalue = wxPyEmptyString ;
3375     wxString *arg4 = (wxString *) &arg4_defvalue ;
3376     wxPoint const &arg5_defvalue = wxDefaultPosition ;
3377     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
3378     wxSize const &arg6_defvalue = wxDefaultSize ;
3379     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
3380     long arg7 = (long) 0 ;
3381     wxValidator const &arg8_defvalue = wxDefaultValidator ;
3382     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
3383     wxString const &arg9_defvalue = wxPyCheckBoxNameStr ;
3384     wxString *arg9 = (wxString *) &arg9_defvalue ;
3385     bool result;
3386     bool temp4 = false ;
3387     wxPoint temp5 ;
3388     wxSize temp6 ;
3389     bool temp9 = false ;
3390     PyObject * obj0 = 0 ;
3391     PyObject * obj1 = 0 ;
3392     PyObject * obj2 = 0 ;
3393     PyObject * obj3 = 0 ;
3394     PyObject * obj4 = 0 ;
3395     PyObject * obj5 = 0 ;
3396     PyObject * obj6 = 0 ;
3397     PyObject * obj7 = 0 ;
3398     PyObject * obj8 = 0 ;
3399     char *kwnames[] = {
3400         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
3401     };
3402
3403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3404     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3405     if (SWIG_arg_fail(1)) SWIG_fail;
3406     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3407     if (SWIG_arg_fail(2)) SWIG_fail;
3408     if (obj2) {
3409         {
3410             arg3 = (int)(SWIG_As_int(obj2));
3411             if (SWIG_arg_fail(3)) SWIG_fail;
3412         }
3413     }
3414     if (obj3) {
3415         {
3416             arg4 = wxString_in_helper(obj3);
3417             if (arg4 == NULL) SWIG_fail;
3418             temp4 = true;
3419         }
3420     }
3421     if (obj4) {
3422         {
3423             arg5 = &temp5;
3424             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
3425         }
3426     }
3427     if (obj5) {
3428         {
3429             arg6 = &temp6;
3430             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
3431         }
3432     }
3433     if (obj6) {
3434         {
3435             arg7 = (long)(SWIG_As_long(obj6));
3436             if (SWIG_arg_fail(7)) SWIG_fail;
3437         }
3438     }
3439     if (obj7) {
3440         {
3441             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3442             if (SWIG_arg_fail(8)) SWIG_fail;
3443             if (arg8 == NULL) {
3444                 SWIG_null_ref("wxValidator");
3445             }
3446             if (SWIG_arg_fail(8)) SWIG_fail;
3447         }
3448     }
3449     if (obj8) {
3450         {
3451             arg9 = wxString_in_helper(obj8);
3452             if (arg9 == NULL) SWIG_fail;
3453             temp9 = true;
3454         }
3455     }
3456     {
3457         PyThreadState* __tstate = wxPyBeginAllowThreads();
3458         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
3459
3460         wxPyEndAllowThreads(__tstate);
3461         if (PyErr_Occurred()) SWIG_fail;
3462     }
3463     {
3464         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3465     }
3466     {
3467         if (temp4)
3468         delete arg4;
3469     }
3470     {
3471         if (temp9)
3472         delete arg9;
3473     }
3474     return resultobj;
3475     fail:
3476     {
3477         if (temp4)
3478         delete arg4;
3479     }
3480     {
3481         if (temp9)
3482         delete arg9;
3483     }
3484     return NULL;
3485 }
3486
3487
3488 static PyObject *_wrap_CheckBox_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
3489     PyObject *resultobj;
3490     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3491     bool result;
3492     PyObject * obj0 = 0 ;
3493     char *kwnames[] = {
3494         (char *) "self", NULL
3495     };
3496
3497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_GetValue",kwnames,&obj0)) goto fail;
3498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3499     if (SWIG_arg_fail(1)) SWIG_fail;
3500     {
3501         PyThreadState* __tstate = wxPyBeginAllowThreads();
3502         result = (bool)(arg1)->GetValue();
3503
3504         wxPyEndAllowThreads(__tstate);
3505         if (PyErr_Occurred()) SWIG_fail;
3506     }
3507     {
3508         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3509     }
3510     return resultobj;
3511     fail:
3512     return NULL;
3513 }
3514
3515
3516 static PyObject *_wrap_CheckBox_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
3517     PyObject *resultobj;
3518     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3519     bool result;
3520     PyObject * obj0 = 0 ;
3521     char *kwnames[] = {
3522         (char *) "self", NULL
3523     };
3524
3525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_IsChecked",kwnames,&obj0)) goto fail;
3526     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3527     if (SWIG_arg_fail(1)) SWIG_fail;
3528     {
3529         PyThreadState* __tstate = wxPyBeginAllowThreads();
3530         result = (bool)(arg1)->IsChecked();
3531
3532         wxPyEndAllowThreads(__tstate);
3533         if (PyErr_Occurred()) SWIG_fail;
3534     }
3535     {
3536         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3537     }
3538     return resultobj;
3539     fail:
3540     return NULL;
3541 }
3542
3543
3544 static PyObject *_wrap_CheckBox_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
3545     PyObject *resultobj;
3546     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3547     bool arg2 ;
3548     PyObject * obj0 = 0 ;
3549     PyObject * obj1 = 0 ;
3550     char *kwnames[] = {
3551         (char *) "self",(char *) "state", NULL
3552     };
3553
3554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_SetValue",kwnames,&obj0,&obj1)) goto fail;
3555     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3556     if (SWIG_arg_fail(1)) SWIG_fail;
3557     {
3558         arg2 = (bool const)(SWIG_As_bool(obj1));
3559         if (SWIG_arg_fail(2)) SWIG_fail;
3560     }
3561     {
3562         PyThreadState* __tstate = wxPyBeginAllowThreads();
3563         (arg1)->SetValue(arg2);
3564
3565         wxPyEndAllowThreads(__tstate);
3566         if (PyErr_Occurred()) SWIG_fail;
3567     }
3568     Py_INCREF(Py_None); resultobj = Py_None;
3569     return resultobj;
3570     fail:
3571     return NULL;
3572 }
3573
3574
3575 static PyObject *_wrap_CheckBox_Get3StateValue(PyObject *, PyObject *args, PyObject *kwargs) {
3576     PyObject *resultobj;
3577     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3578     wxCheckBoxState result;
3579     PyObject * obj0 = 0 ;
3580     char *kwnames[] = {
3581         (char *) "self", NULL
3582     };
3583
3584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Get3StateValue",kwnames,&obj0)) goto fail;
3585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3586     if (SWIG_arg_fail(1)) SWIG_fail;
3587     {
3588         PyThreadState* __tstate = wxPyBeginAllowThreads();
3589         result = (wxCheckBoxState)((wxCheckBox const *)arg1)->Get3StateValue();
3590
3591         wxPyEndAllowThreads(__tstate);
3592         if (PyErr_Occurred()) SWIG_fail;
3593     }
3594     resultobj = SWIG_From_int((result));
3595     return resultobj;
3596     fail:
3597     return NULL;
3598 }
3599
3600
3601 static PyObject *_wrap_CheckBox_Set3StateValue(PyObject *, PyObject *args, PyObject *kwargs) {
3602     PyObject *resultobj;
3603     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3604     wxCheckBoxState arg2 ;
3605     PyObject * obj0 = 0 ;
3606     PyObject * obj1 = 0 ;
3607     char *kwnames[] = {
3608         (char *) "self",(char *) "state", NULL
3609     };
3610
3611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_Set3StateValue",kwnames,&obj0,&obj1)) goto fail;
3612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3613     if (SWIG_arg_fail(1)) SWIG_fail;
3614     {
3615         arg2 = (wxCheckBoxState)(SWIG_As_int(obj1));
3616         if (SWIG_arg_fail(2)) SWIG_fail;
3617     }
3618     {
3619         PyThreadState* __tstate = wxPyBeginAllowThreads();
3620         (arg1)->Set3StateValue((wxCheckBoxState )arg2);
3621
3622         wxPyEndAllowThreads(__tstate);
3623         if (PyErr_Occurred()) SWIG_fail;
3624     }
3625     Py_INCREF(Py_None); resultobj = Py_None;
3626     return resultobj;
3627     fail:
3628     return NULL;
3629 }
3630
3631
3632 static PyObject *_wrap_CheckBox_Is3State(PyObject *, PyObject *args, PyObject *kwargs) {
3633     PyObject *resultobj;
3634     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3635     bool result;
3636     PyObject * obj0 = 0 ;
3637     char *kwnames[] = {
3638         (char *) "self", NULL
3639     };
3640
3641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Is3State",kwnames,&obj0)) goto fail;
3642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3643     if (SWIG_arg_fail(1)) SWIG_fail;
3644     {
3645         PyThreadState* __tstate = wxPyBeginAllowThreads();
3646         result = (bool)((wxCheckBox const *)arg1)->Is3State();
3647
3648         wxPyEndAllowThreads(__tstate);
3649         if (PyErr_Occurred()) SWIG_fail;
3650     }
3651     {
3652         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3653     }
3654     return resultobj;
3655     fail:
3656     return NULL;
3657 }
3658
3659
3660 static PyObject *_wrap_CheckBox_Is3rdStateAllowedForUser(PyObject *, PyObject *args, PyObject *kwargs) {
3661     PyObject *resultobj;
3662     wxCheckBox *arg1 = (wxCheckBox *) 0 ;
3663     bool result;
3664     PyObject * obj0 = 0 ;
3665     char *kwnames[] = {
3666         (char *) "self", NULL
3667     };
3668
3669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckBox_Is3rdStateAllowedForUser",kwnames,&obj0)) goto fail;
3670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckBox, SWIG_POINTER_EXCEPTION | 0);
3671     if (SWIG_arg_fail(1)) SWIG_fail;
3672     {
3673         PyThreadState* __tstate = wxPyBeginAllowThreads();
3674         result = (bool)((wxCheckBox const *)arg1)->Is3rdStateAllowedForUser();
3675
3676         wxPyEndAllowThreads(__tstate);
3677         if (PyErr_Occurred()) SWIG_fail;
3678     }
3679     {
3680         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3681     }
3682     return resultobj;
3683     fail:
3684     return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_CheckBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3689     PyObject *resultobj;
3690     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3691     wxVisualAttributes result;
3692     PyObject * obj0 = 0 ;
3693     char *kwnames[] = {
3694         (char *) "variant", NULL
3695     };
3696
3697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:CheckBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3698     if (obj0) {
3699         {
3700             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
3701             if (SWIG_arg_fail(1)) SWIG_fail;
3702         }
3703     }
3704     {
3705         if (!wxPyCheckForApp()) SWIG_fail;
3706         PyThreadState* __tstate = wxPyBeginAllowThreads();
3707         result = wxCheckBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
3708
3709         wxPyEndAllowThreads(__tstate);
3710         if (PyErr_Occurred()) SWIG_fail;
3711     }
3712     {
3713         wxVisualAttributes * resultptr;
3714         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
3715         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
3716     }
3717     return resultobj;
3718     fail:
3719     return NULL;
3720 }
3721
3722
3723 static PyObject * CheckBox_swigregister(PyObject *, PyObject *args) {
3724     PyObject *obj;
3725     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3726     SWIG_TypeClientData(SWIGTYPE_p_wxCheckBox, obj);
3727     Py_INCREF(obj);
3728     return Py_BuildValue((char *)"");
3729 }
3730 static int _wrap_ChoiceNameStr_set(PyObject *) {
3731     PyErr_SetString(PyExc_TypeError,"Variable ChoiceNameStr is read-only.");
3732     return 1;
3733 }
3734
3735
3736 static PyObject *_wrap_ChoiceNameStr_get(void) {
3737     PyObject *pyobj;
3738
3739     {
3740 #if wxUSE_UNICODE
3741         pyobj = PyUnicode_FromWideChar((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
3742 #else
3743         pyobj = PyString_FromStringAndSize((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
3744 #endif
3745     }
3746     return pyobj;
3747 }
3748
3749
3750 static PyObject *_wrap_new_Choice(PyObject *, PyObject *args, PyObject *kwargs) {
3751     PyObject *resultobj;
3752     wxWindow *arg1 = (wxWindow *) 0 ;
3753     int arg2 = (int) -1 ;
3754     wxPoint const &arg3_defvalue = wxDefaultPosition ;
3755     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
3756     wxSize const &arg4_defvalue = wxDefaultSize ;
3757     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
3758     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
3759     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
3760     long arg6 = (long) 0 ;
3761     wxValidator const &arg7_defvalue = wxDefaultValidator ;
3762     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
3763     wxString const &arg8_defvalue = wxPyChoiceNameStr ;
3764     wxString *arg8 = (wxString *) &arg8_defvalue ;
3765     wxChoice *result;
3766     wxPoint temp3 ;
3767     wxSize temp4 ;
3768     bool temp5 = false ;
3769     bool temp8 = false ;
3770     PyObject * obj0 = 0 ;
3771     PyObject * obj1 = 0 ;
3772     PyObject * obj2 = 0 ;
3773     PyObject * obj3 = 0 ;
3774     PyObject * obj4 = 0 ;
3775     PyObject * obj5 = 0 ;
3776     PyObject * obj6 = 0 ;
3777     PyObject * obj7 = 0 ;
3778     char *kwnames[] = {
3779         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
3780     };
3781
3782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Choice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3783     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3784     if (SWIG_arg_fail(1)) SWIG_fail;
3785     if (obj1) {
3786         {
3787             arg2 = (int)(SWIG_As_int(obj1));
3788             if (SWIG_arg_fail(2)) SWIG_fail;
3789         }
3790     }
3791     if (obj2) {
3792         {
3793             arg3 = &temp3;
3794             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
3795         }
3796     }
3797     if (obj3) {
3798         {
3799             arg4 = &temp4;
3800             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
3801         }
3802     }
3803     if (obj4) {
3804         {
3805             if (! PySequence_Check(obj4)) {
3806                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
3807                 SWIG_fail;
3808             }
3809             arg5 = new wxArrayString;
3810             temp5 = true;
3811             int i, len=PySequence_Length(obj4);
3812             for (i=0; i<len; i++) {
3813                 PyObject* item = PySequence_GetItem(obj4, i);
3814 #if wxUSE_UNICODE
3815                 PyObject* str  = PyObject_Unicode(item);
3816 #else
3817                 PyObject* str  = PyObject_Str(item);
3818 #endif
3819                 if (PyErr_Occurred())  SWIG_fail;
3820                 arg5->Add(Py2wxString(str));
3821                 Py_DECREF(item);
3822                 Py_DECREF(str);
3823             }
3824         }
3825     }
3826     if (obj5) {
3827         {
3828             arg6 = (long)(SWIG_As_long(obj5));
3829             if (SWIG_arg_fail(6)) SWIG_fail;
3830         }
3831     }
3832     if (obj6) {
3833         {
3834             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3835             if (SWIG_arg_fail(7)) SWIG_fail;
3836             if (arg7 == NULL) {
3837                 SWIG_null_ref("wxValidator");
3838             }
3839             if (SWIG_arg_fail(7)) SWIG_fail;
3840         }
3841     }
3842     if (obj7) {
3843         {
3844             arg8 = wxString_in_helper(obj7);
3845             if (arg8 == NULL) SWIG_fail;
3846             temp8 = true;
3847         }
3848     }
3849     {
3850         if (!wxPyCheckForApp()) SWIG_fail;
3851         PyThreadState* __tstate = wxPyBeginAllowThreads();
3852         result = (wxChoice *)new wxChoice(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
3853
3854         wxPyEndAllowThreads(__tstate);
3855         if (PyErr_Occurred()) SWIG_fail;
3856     }
3857     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoice, 1);
3858     {
3859         if (temp5) delete arg5;
3860     }
3861     {
3862         if (temp8)
3863         delete arg8;
3864     }
3865     return resultobj;
3866     fail:
3867     {
3868         if (temp5) delete arg5;
3869     }
3870     {
3871         if (temp8)
3872         delete arg8;
3873     }
3874     return NULL;
3875 }
3876
3877
3878 static PyObject *_wrap_new_PreChoice(PyObject *, PyObject *args, PyObject *kwargs) {
3879     PyObject *resultobj;
3880     wxChoice *result;
3881     char *kwnames[] = {
3882         NULL
3883     };
3884
3885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreChoice",kwnames)) goto fail;
3886     {
3887         if (!wxPyCheckForApp()) SWIG_fail;
3888         PyThreadState* __tstate = wxPyBeginAllowThreads();
3889         result = (wxChoice *)new wxChoice();
3890
3891         wxPyEndAllowThreads(__tstate);
3892         if (PyErr_Occurred()) SWIG_fail;
3893     }
3894     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoice, 1);
3895     return resultobj;
3896     fail:
3897     return NULL;
3898 }
3899
3900
3901 static PyObject *_wrap_Choice_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3902     PyObject *resultobj;
3903     wxChoice *arg1 = (wxChoice *) 0 ;
3904     wxWindow *arg2 = (wxWindow *) 0 ;
3905     int arg3 = (int) -1 ;
3906     wxPoint const &arg4_defvalue = wxDefaultPosition ;
3907     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
3908     wxSize const &arg5_defvalue = wxDefaultSize ;
3909     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
3910     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
3911     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
3912     long arg7 = (long) 0 ;
3913     wxValidator const &arg8_defvalue = wxDefaultValidator ;
3914     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
3915     wxString const &arg9_defvalue = wxPyChoiceNameStr ;
3916     wxString *arg9 = (wxString *) &arg9_defvalue ;
3917     bool result;
3918     wxPoint temp4 ;
3919     wxSize temp5 ;
3920     bool temp6 = false ;
3921     bool temp9 = false ;
3922     PyObject * obj0 = 0 ;
3923     PyObject * obj1 = 0 ;
3924     PyObject * obj2 = 0 ;
3925     PyObject * obj3 = 0 ;
3926     PyObject * obj4 = 0 ;
3927     PyObject * obj5 = 0 ;
3928     PyObject * obj6 = 0 ;
3929     PyObject * obj7 = 0 ;
3930     PyObject * obj8 = 0 ;
3931     char *kwnames[] = {
3932         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
3933     };
3934
3935     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Choice_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3936     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
3937     if (SWIG_arg_fail(1)) SWIG_fail;
3938     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3939     if (SWIG_arg_fail(2)) SWIG_fail;
3940     if (obj2) {
3941         {
3942             arg3 = (int)(SWIG_As_int(obj2));
3943             if (SWIG_arg_fail(3)) SWIG_fail;
3944         }
3945     }
3946     if (obj3) {
3947         {
3948             arg4 = &temp4;
3949             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3950         }
3951     }
3952     if (obj4) {
3953         {
3954             arg5 = &temp5;
3955             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3956         }
3957     }
3958     if (obj5) {
3959         {
3960             if (! PySequence_Check(obj5)) {
3961                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
3962                 SWIG_fail;
3963             }
3964             arg6 = new wxArrayString;
3965             temp6 = true;
3966             int i, len=PySequence_Length(obj5);
3967             for (i=0; i<len; i++) {
3968                 PyObject* item = PySequence_GetItem(obj5, i);
3969 #if wxUSE_UNICODE
3970                 PyObject* str  = PyObject_Unicode(item);
3971 #else
3972                 PyObject* str  = PyObject_Str(item);
3973 #endif
3974                 if (PyErr_Occurred())  SWIG_fail;
3975                 arg6->Add(Py2wxString(str));
3976                 Py_DECREF(item);
3977                 Py_DECREF(str);
3978             }
3979         }
3980     }
3981     if (obj6) {
3982         {
3983             arg7 = (long)(SWIG_As_long(obj6));
3984             if (SWIG_arg_fail(7)) SWIG_fail;
3985         }
3986     }
3987     if (obj7) {
3988         {
3989             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
3990             if (SWIG_arg_fail(8)) SWIG_fail;
3991             if (arg8 == NULL) {
3992                 SWIG_null_ref("wxValidator");
3993             }
3994             if (SWIG_arg_fail(8)) SWIG_fail;
3995         }
3996     }
3997     if (obj8) {
3998         {
3999             arg9 = wxString_in_helper(obj8);
4000             if (arg9 == NULL) SWIG_fail;
4001             temp9 = true;
4002         }
4003     }
4004     {
4005         PyThreadState* __tstate = wxPyBeginAllowThreads();
4006         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
4007
4008         wxPyEndAllowThreads(__tstate);
4009         if (PyErr_Occurred()) SWIG_fail;
4010     }
4011     {
4012         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4013     }
4014     {
4015         if (temp6) delete arg6;
4016     }
4017     {
4018         if (temp9)
4019         delete arg9;
4020     }
4021     return resultobj;
4022     fail:
4023     {
4024         if (temp6) delete arg6;
4025     }
4026     {
4027         if (temp9)
4028         delete arg9;
4029     }
4030     return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_Choice_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4035     PyObject *resultobj;
4036     wxChoice *arg1 = (wxChoice *) 0 ;
4037     int arg2 ;
4038     PyObject * obj0 = 0 ;
4039     PyObject * obj1 = 0 ;
4040     char *kwnames[] = {
4041         (char *) "self",(char *) "n", NULL
4042     };
4043
4044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Choice_SetSelection",kwnames,&obj0,&obj1)) goto fail;
4045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4046     if (SWIG_arg_fail(1)) SWIG_fail;
4047     {
4048         arg2 = (int const)(SWIG_As_int(obj1));
4049         if (SWIG_arg_fail(2)) SWIG_fail;
4050     }
4051     {
4052         PyThreadState* __tstate = wxPyBeginAllowThreads();
4053         (arg1)->SetSelection(arg2);
4054
4055         wxPyEndAllowThreads(__tstate);
4056         if (PyErr_Occurred()) SWIG_fail;
4057     }
4058     Py_INCREF(Py_None); resultobj = Py_None;
4059     return resultobj;
4060     fail:
4061     return NULL;
4062 }
4063
4064
4065 static PyObject *_wrap_Choice_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4066     PyObject *resultobj;
4067     wxChoice *arg1 = (wxChoice *) 0 ;
4068     wxString *arg2 = 0 ;
4069     bool result;
4070     bool temp2 = false ;
4071     PyObject * obj0 = 0 ;
4072     PyObject * obj1 = 0 ;
4073     char *kwnames[] = {
4074         (char *) "self",(char *) "string", NULL
4075     };
4076
4077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Choice_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
4078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4079     if (SWIG_arg_fail(1)) SWIG_fail;
4080     {
4081         arg2 = wxString_in_helper(obj1);
4082         if (arg2 == NULL) SWIG_fail;
4083         temp2 = true;
4084     }
4085     {
4086         PyThreadState* __tstate = wxPyBeginAllowThreads();
4087         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
4088
4089         wxPyEndAllowThreads(__tstate);
4090         if (PyErr_Occurred()) SWIG_fail;
4091     }
4092     {
4093         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4094     }
4095     {
4096         if (temp2)
4097         delete arg2;
4098     }
4099     return resultobj;
4100     fail:
4101     {
4102         if (temp2)
4103         delete arg2;
4104     }
4105     return NULL;
4106 }
4107
4108
4109 static PyObject *_wrap_Choice_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
4110     PyObject *resultobj;
4111     wxChoice *arg1 = (wxChoice *) 0 ;
4112     int arg2 ;
4113     wxString *arg3 = 0 ;
4114     bool temp3 = false ;
4115     PyObject * obj0 = 0 ;
4116     PyObject * obj1 = 0 ;
4117     PyObject * obj2 = 0 ;
4118     char *kwnames[] = {
4119         (char *) "self",(char *) "n",(char *) "string", NULL
4120     };
4121
4122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Choice_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
4123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoice, SWIG_POINTER_EXCEPTION | 0);
4124     if (SWIG_arg_fail(1)) SWIG_fail;
4125     {
4126         arg2 = (int)(SWIG_As_int(obj1));
4127         if (SWIG_arg_fail(2)) SWIG_fail;
4128     }
4129     {
4130         arg3 = wxString_in_helper(obj2);
4131         if (arg3 == NULL) SWIG_fail;
4132         temp3 = true;
4133     }
4134     {
4135         PyThreadState* __tstate = wxPyBeginAllowThreads();
4136         (arg1)->SetString(arg2,(wxString const &)*arg3);
4137
4138         wxPyEndAllowThreads(__tstate);
4139         if (PyErr_Occurred()) SWIG_fail;
4140     }
4141     Py_INCREF(Py_None); resultobj = Py_None;
4142     {
4143         if (temp3)
4144         delete arg3;
4145     }
4146     return resultobj;
4147     fail:
4148     {
4149         if (temp3)
4150         delete arg3;
4151     }
4152     return NULL;
4153 }
4154
4155
4156 static PyObject *_wrap_Choice_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
4157     PyObject *resultobj;
4158     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
4159     wxVisualAttributes result;
4160     PyObject * obj0 = 0 ;
4161     char *kwnames[] = {
4162         (char *) "variant", NULL
4163     };
4164
4165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Choice_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
4166     if (obj0) {
4167         {
4168             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
4169             if (SWIG_arg_fail(1)) SWIG_fail;
4170         }
4171     }
4172     {
4173         if (!wxPyCheckForApp()) SWIG_fail;
4174         PyThreadState* __tstate = wxPyBeginAllowThreads();
4175         result = wxChoice::GetClassDefaultAttributes((wxWindowVariant )arg1);
4176
4177         wxPyEndAllowThreads(__tstate);
4178         if (PyErr_Occurred()) SWIG_fail;
4179     }
4180     {
4181         wxVisualAttributes * resultptr;
4182         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
4183         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
4184     }
4185     return resultobj;
4186     fail:
4187     return NULL;
4188 }
4189
4190
4191 static PyObject * Choice_swigregister(PyObject *, PyObject *args) {
4192     PyObject *obj;
4193     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4194     SWIG_TypeClientData(SWIGTYPE_p_wxChoice, obj);
4195     Py_INCREF(obj);
4196     return Py_BuildValue((char *)"");
4197 }
4198 static int _wrap_ComboBoxNameStr_set(PyObject *) {
4199     PyErr_SetString(PyExc_TypeError,"Variable ComboBoxNameStr is read-only.");
4200     return 1;
4201 }
4202
4203
4204 static PyObject *_wrap_ComboBoxNameStr_get(void) {
4205     PyObject *pyobj;
4206
4207     {
4208 #if wxUSE_UNICODE
4209         pyobj = PyUnicode_FromWideChar((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
4210 #else
4211         pyobj = PyString_FromStringAndSize((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
4212 #endif
4213     }
4214     return pyobj;
4215 }
4216
4217
4218 static PyObject *_wrap_new_ComboBox(PyObject *, PyObject *args, PyObject *kwargs) {
4219     PyObject *resultobj;
4220     wxWindow *arg1 = (wxWindow *) 0 ;
4221     int arg2 = (int) -1 ;
4222     wxString const &arg3_defvalue = wxPyEmptyString ;
4223     wxString *arg3 = (wxString *) &arg3_defvalue ;
4224     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4225     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4226     wxSize const &arg5_defvalue = wxDefaultSize ;
4227     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4228     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
4229     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
4230     long arg7 = (long) 0 ;
4231     wxValidator const &arg8_defvalue = wxDefaultValidator ;
4232     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
4233     wxString const &arg9_defvalue = wxPyComboBoxNameStr ;
4234     wxString *arg9 = (wxString *) &arg9_defvalue ;
4235     wxComboBox *result;
4236     bool temp3 = false ;
4237     wxPoint temp4 ;
4238     wxSize temp5 ;
4239     bool temp6 = false ;
4240     bool temp9 = false ;
4241     PyObject * obj0 = 0 ;
4242     PyObject * obj1 = 0 ;
4243     PyObject * obj2 = 0 ;
4244     PyObject * obj3 = 0 ;
4245     PyObject * obj4 = 0 ;
4246     PyObject * obj5 = 0 ;
4247     PyObject * obj6 = 0 ;
4248     PyObject * obj7 = 0 ;
4249     PyObject * obj8 = 0 ;
4250     char *kwnames[] = {
4251         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
4252     };
4253
4254     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_ComboBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4255     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4256     if (SWIG_arg_fail(1)) SWIG_fail;
4257     if (obj1) {
4258         {
4259             arg2 = (int)(SWIG_As_int(obj1));
4260             if (SWIG_arg_fail(2)) SWIG_fail;
4261         }
4262     }
4263     if (obj2) {
4264         {
4265             arg3 = wxString_in_helper(obj2);
4266             if (arg3 == NULL) SWIG_fail;
4267             temp3 = true;
4268         }
4269     }
4270     if (obj3) {
4271         {
4272             arg4 = &temp4;
4273             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4274         }
4275     }
4276     if (obj4) {
4277         {
4278             arg5 = &temp5;
4279             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4280         }
4281     }
4282     if (obj5) {
4283         {
4284             if (! PySequence_Check(obj5)) {
4285                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
4286                 SWIG_fail;
4287             }
4288             arg6 = new wxArrayString;
4289             temp6 = true;
4290             int i, len=PySequence_Length(obj5);
4291             for (i=0; i<len; i++) {
4292                 PyObject* item = PySequence_GetItem(obj5, i);
4293 #if wxUSE_UNICODE
4294                 PyObject* str  = PyObject_Unicode(item);
4295 #else
4296                 PyObject* str  = PyObject_Str(item);
4297 #endif
4298                 if (PyErr_Occurred())  SWIG_fail;
4299                 arg6->Add(Py2wxString(str));
4300                 Py_DECREF(item);
4301                 Py_DECREF(str);
4302             }
4303         }
4304     }
4305     if (obj6) {
4306         {
4307             arg7 = (long)(SWIG_As_long(obj6));
4308             if (SWIG_arg_fail(7)) SWIG_fail;
4309         }
4310     }
4311     if (obj7) {
4312         {
4313             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
4314             if (SWIG_arg_fail(8)) SWIG_fail;
4315             if (arg8 == NULL) {
4316                 SWIG_null_ref("wxValidator");
4317             }
4318             if (SWIG_arg_fail(8)) SWIG_fail;
4319         }
4320     }
4321     if (obj8) {
4322         {
4323             arg9 = wxString_in_helper(obj8);
4324             if (arg9 == NULL) SWIG_fail;
4325             temp9 = true;
4326         }
4327     }
4328     {
4329         if (!wxPyCheckForApp()) SWIG_fail;
4330         PyThreadState* __tstate = wxPyBeginAllowThreads();
4331         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);
4332
4333         wxPyEndAllowThreads(__tstate);
4334         if (PyErr_Occurred()) SWIG_fail;
4335     }
4336     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxComboBox, 1);
4337     {
4338         if (temp3)
4339         delete arg3;
4340     }
4341     {
4342         if (temp6) delete arg6;
4343     }
4344     {
4345         if (temp9)
4346         delete arg9;
4347     }
4348     return resultobj;
4349     fail:
4350     {
4351         if (temp3)
4352         delete arg3;
4353     }
4354     {
4355         if (temp6) delete arg6;
4356     }
4357     {
4358         if (temp9)
4359         delete arg9;
4360     }
4361     return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_new_PreComboBox(PyObject *, PyObject *args, PyObject *kwargs) {
4366     PyObject *resultobj;
4367     wxComboBox *result;
4368     char *kwnames[] = {
4369         NULL
4370     };
4371
4372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreComboBox",kwnames)) goto fail;
4373     {
4374         if (!wxPyCheckForApp()) SWIG_fail;
4375         PyThreadState* __tstate = wxPyBeginAllowThreads();
4376         result = (wxComboBox *)new wxComboBox();
4377
4378         wxPyEndAllowThreads(__tstate);
4379         if (PyErr_Occurred()) SWIG_fail;
4380     }
4381     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxComboBox, 1);
4382     return resultobj;
4383     fail:
4384     return NULL;
4385 }
4386
4387
4388 static PyObject *_wrap_ComboBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4389     PyObject *resultobj;
4390     wxComboBox *arg1 = (wxComboBox *) 0 ;
4391     wxWindow *arg2 = (wxWindow *) 0 ;
4392     int arg3 = (int) -1 ;
4393     wxString const &arg4_defvalue = wxPyEmptyString ;
4394     wxString *arg4 = (wxString *) &arg4_defvalue ;
4395     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4396     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4397     wxSize const &arg6_defvalue = wxDefaultSize ;
4398     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4399     wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
4400     wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
4401     long arg8 = (long) 0 ;
4402     wxValidator const &arg9_defvalue = wxDefaultValidator ;
4403     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
4404     wxString const &arg10_defvalue = wxPyChoiceNameStr ;
4405     wxString *arg10 = (wxString *) &arg10_defvalue ;
4406     bool result;
4407     bool temp4 = false ;
4408     wxPoint temp5 ;
4409     wxSize temp6 ;
4410     bool temp7 = false ;
4411     bool temp10 = false ;
4412     PyObject * obj0 = 0 ;
4413     PyObject * obj1 = 0 ;
4414     PyObject * obj2 = 0 ;
4415     PyObject * obj3 = 0 ;
4416     PyObject * obj4 = 0 ;
4417     PyObject * obj5 = 0 ;
4418     PyObject * obj6 = 0 ;
4419     PyObject * obj7 = 0 ;
4420     PyObject * obj8 = 0 ;
4421     PyObject * obj9 = 0 ;
4422     char *kwnames[] = {
4423         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
4424     };
4425
4426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:ComboBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
4427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4428     if (SWIG_arg_fail(1)) SWIG_fail;
4429     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4430     if (SWIG_arg_fail(2)) SWIG_fail;
4431     if (obj2) {
4432         {
4433             arg3 = (int)(SWIG_As_int(obj2));
4434             if (SWIG_arg_fail(3)) SWIG_fail;
4435         }
4436     }
4437     if (obj3) {
4438         {
4439             arg4 = wxString_in_helper(obj3);
4440             if (arg4 == NULL) SWIG_fail;
4441             temp4 = true;
4442         }
4443     }
4444     if (obj4) {
4445         {
4446             arg5 = &temp5;
4447             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4448         }
4449     }
4450     if (obj5) {
4451         {
4452             arg6 = &temp6;
4453             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4454         }
4455     }
4456     if (obj6) {
4457         {
4458             if (! PySequence_Check(obj6)) {
4459                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
4460                 SWIG_fail;
4461             }
4462             arg7 = new wxArrayString;
4463             temp7 = true;
4464             int i, len=PySequence_Length(obj6);
4465             for (i=0; i<len; i++) {
4466                 PyObject* item = PySequence_GetItem(obj6, i);
4467 #if wxUSE_UNICODE
4468                 PyObject* str  = PyObject_Unicode(item);
4469 #else
4470                 PyObject* str  = PyObject_Str(item);
4471 #endif
4472                 if (PyErr_Occurred())  SWIG_fail;
4473                 arg7->Add(Py2wxString(str));
4474                 Py_DECREF(item);
4475                 Py_DECREF(str);
4476             }
4477         }
4478     }
4479     if (obj7) {
4480         {
4481             arg8 = (long)(SWIG_As_long(obj7));
4482             if (SWIG_arg_fail(8)) SWIG_fail;
4483         }
4484     }
4485     if (obj8) {
4486         {
4487             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
4488             if (SWIG_arg_fail(9)) SWIG_fail;
4489             if (arg9 == NULL) {
4490                 SWIG_null_ref("wxValidator");
4491             }
4492             if (SWIG_arg_fail(9)) SWIG_fail;
4493         }
4494     }
4495     if (obj9) {
4496         {
4497             arg10 = wxString_in_helper(obj9);
4498             if (arg10 == NULL) SWIG_fail;
4499             temp10 = true;
4500         }
4501     }
4502     {
4503         PyThreadState* __tstate = wxPyBeginAllowThreads();
4504         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);
4505
4506         wxPyEndAllowThreads(__tstate);
4507         if (PyErr_Occurred()) SWIG_fail;
4508     }
4509     {
4510         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4511     }
4512     {
4513         if (temp4)
4514         delete arg4;
4515     }
4516     {
4517         if (temp7) delete arg7;
4518     }
4519     {
4520         if (temp10)
4521         delete arg10;
4522     }
4523     return resultobj;
4524     fail:
4525     {
4526         if (temp4)
4527         delete arg4;
4528     }
4529     {
4530         if (temp7) delete arg7;
4531     }
4532     {
4533         if (temp10)
4534         delete arg10;
4535     }
4536     return NULL;
4537 }
4538
4539
4540 static PyObject *_wrap_ComboBox_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4541     PyObject *resultobj;
4542     wxComboBox *arg1 = (wxComboBox *) 0 ;
4543     wxString result;
4544     PyObject * obj0 = 0 ;
4545     char *kwnames[] = {
4546         (char *) "self", NULL
4547     };
4548
4549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetValue",kwnames,&obj0)) goto fail;
4550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4551     if (SWIG_arg_fail(1)) SWIG_fail;
4552     {
4553         PyThreadState* __tstate = wxPyBeginAllowThreads();
4554         result = ((wxComboBox const *)arg1)->GetValue();
4555
4556         wxPyEndAllowThreads(__tstate);
4557         if (PyErr_Occurred()) SWIG_fail;
4558     }
4559     {
4560 #if wxUSE_UNICODE
4561         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4562 #else
4563         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4564 #endif
4565     }
4566     return resultobj;
4567     fail:
4568     return NULL;
4569 }
4570
4571
4572 static PyObject *_wrap_ComboBox_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4573     PyObject *resultobj;
4574     wxComboBox *arg1 = (wxComboBox *) 0 ;
4575     wxString *arg2 = 0 ;
4576     bool temp2 = false ;
4577     PyObject * obj0 = 0 ;
4578     PyObject * obj1 = 0 ;
4579     char *kwnames[] = {
4580         (char *) "self",(char *) "value", NULL
4581     };
4582
4583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetValue",kwnames,&obj0,&obj1)) goto fail;
4584     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4585     if (SWIG_arg_fail(1)) SWIG_fail;
4586     {
4587         arg2 = wxString_in_helper(obj1);
4588         if (arg2 == NULL) SWIG_fail;
4589         temp2 = true;
4590     }
4591     {
4592         PyThreadState* __tstate = wxPyBeginAllowThreads();
4593         (arg1)->SetValue((wxString const &)*arg2);
4594
4595         wxPyEndAllowThreads(__tstate);
4596         if (PyErr_Occurred()) SWIG_fail;
4597     }
4598     Py_INCREF(Py_None); resultobj = Py_None;
4599     {
4600         if (temp2)
4601         delete arg2;
4602     }
4603     return resultobj;
4604     fail:
4605     {
4606         if (temp2)
4607         delete arg2;
4608     }
4609     return NULL;
4610 }
4611
4612
4613 static PyObject *_wrap_ComboBox_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
4614     PyObject *resultobj;
4615     wxComboBox *arg1 = (wxComboBox *) 0 ;
4616     PyObject * obj0 = 0 ;
4617     char *kwnames[] = {
4618         (char *) "self", NULL
4619     };
4620
4621     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Copy",kwnames,&obj0)) goto fail;
4622     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4623     if (SWIG_arg_fail(1)) SWIG_fail;
4624     {
4625         PyThreadState* __tstate = wxPyBeginAllowThreads();
4626         (arg1)->Copy();
4627
4628         wxPyEndAllowThreads(__tstate);
4629         if (PyErr_Occurred()) SWIG_fail;
4630     }
4631     Py_INCREF(Py_None); resultobj = Py_None;
4632     return resultobj;
4633     fail:
4634     return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_ComboBox_Cut(PyObject *, PyObject *args, PyObject *kwargs) {
4639     PyObject *resultobj;
4640     wxComboBox *arg1 = (wxComboBox *) 0 ;
4641     PyObject * obj0 = 0 ;
4642     char *kwnames[] = {
4643         (char *) "self", NULL
4644     };
4645
4646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Cut",kwnames,&obj0)) goto fail;
4647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4648     if (SWIG_arg_fail(1)) SWIG_fail;
4649     {
4650         PyThreadState* __tstate = wxPyBeginAllowThreads();
4651         (arg1)->Cut();
4652
4653         wxPyEndAllowThreads(__tstate);
4654         if (PyErr_Occurred()) SWIG_fail;
4655     }
4656     Py_INCREF(Py_None); resultobj = Py_None;
4657     return resultobj;
4658     fail:
4659     return NULL;
4660 }
4661
4662
4663 static PyObject *_wrap_ComboBox_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
4664     PyObject *resultobj;
4665     wxComboBox *arg1 = (wxComboBox *) 0 ;
4666     PyObject * obj0 = 0 ;
4667     char *kwnames[] = {
4668         (char *) "self", NULL
4669     };
4670
4671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Paste",kwnames,&obj0)) goto fail;
4672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4673     if (SWIG_arg_fail(1)) SWIG_fail;
4674     {
4675         PyThreadState* __tstate = wxPyBeginAllowThreads();
4676         (arg1)->Paste();
4677
4678         wxPyEndAllowThreads(__tstate);
4679         if (PyErr_Occurred()) SWIG_fail;
4680     }
4681     Py_INCREF(Py_None); resultobj = Py_None;
4682     return resultobj;
4683     fail:
4684     return NULL;
4685 }
4686
4687
4688 static PyObject *_wrap_ComboBox_SetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4689     PyObject *resultobj;
4690     wxComboBox *arg1 = (wxComboBox *) 0 ;
4691     long arg2 ;
4692     PyObject * obj0 = 0 ;
4693     PyObject * obj1 = 0 ;
4694     char *kwnames[] = {
4695         (char *) "self",(char *) "pos", NULL
4696     };
4697
4698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetInsertionPoint",kwnames,&obj0,&obj1)) goto fail;
4699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4700     if (SWIG_arg_fail(1)) SWIG_fail;
4701     {
4702         arg2 = (long)(SWIG_As_long(obj1));
4703         if (SWIG_arg_fail(2)) SWIG_fail;
4704     }
4705     {
4706         PyThreadState* __tstate = wxPyBeginAllowThreads();
4707         (arg1)->SetInsertionPoint(arg2);
4708
4709         wxPyEndAllowThreads(__tstate);
4710         if (PyErr_Occurred()) SWIG_fail;
4711     }
4712     Py_INCREF(Py_None); resultobj = Py_None;
4713     return resultobj;
4714     fail:
4715     return NULL;
4716 }
4717
4718
4719 static PyObject *_wrap_ComboBox_GetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4720     PyObject *resultobj;
4721     wxComboBox *arg1 = (wxComboBox *) 0 ;
4722     long result;
4723     PyObject * obj0 = 0 ;
4724     char *kwnames[] = {
4725         (char *) "self", NULL
4726     };
4727
4728     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetInsertionPoint",kwnames,&obj0)) goto fail;
4729     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4730     if (SWIG_arg_fail(1)) SWIG_fail;
4731     {
4732         PyThreadState* __tstate = wxPyBeginAllowThreads();
4733         result = (long)((wxComboBox const *)arg1)->GetInsertionPoint();
4734
4735         wxPyEndAllowThreads(__tstate);
4736         if (PyErr_Occurred()) SWIG_fail;
4737     }
4738     {
4739         resultobj = SWIG_From_long((long)(result));
4740     }
4741     return resultobj;
4742     fail:
4743     return NULL;
4744 }
4745
4746
4747 static PyObject *_wrap_ComboBox_GetLastPosition(PyObject *, PyObject *args, PyObject *kwargs) {
4748     PyObject *resultobj;
4749     wxComboBox *arg1 = (wxComboBox *) 0 ;
4750     long result;
4751     PyObject * obj0 = 0 ;
4752     char *kwnames[] = {
4753         (char *) "self", NULL
4754     };
4755
4756     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetLastPosition",kwnames,&obj0)) goto fail;
4757     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4758     if (SWIG_arg_fail(1)) SWIG_fail;
4759     {
4760         PyThreadState* __tstate = wxPyBeginAllowThreads();
4761         result = (long)((wxComboBox const *)arg1)->GetLastPosition();
4762
4763         wxPyEndAllowThreads(__tstate);
4764         if (PyErr_Occurred()) SWIG_fail;
4765     }
4766     {
4767         resultobj = SWIG_From_long((long)(result));
4768     }
4769     return resultobj;
4770     fail:
4771     return NULL;
4772 }
4773
4774
4775 static PyObject *_wrap_ComboBox_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
4776     PyObject *resultobj;
4777     wxComboBox *arg1 = (wxComboBox *) 0 ;
4778     long arg2 ;
4779     long arg3 ;
4780     wxString *arg4 = 0 ;
4781     bool temp4 = false ;
4782     PyObject * obj0 = 0 ;
4783     PyObject * obj1 = 0 ;
4784     PyObject * obj2 = 0 ;
4785     PyObject * obj3 = 0 ;
4786     char *kwnames[] = {
4787         (char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL
4788     };
4789
4790     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ComboBox_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4791     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4792     if (SWIG_arg_fail(1)) SWIG_fail;
4793     {
4794         arg2 = (long)(SWIG_As_long(obj1));
4795         if (SWIG_arg_fail(2)) SWIG_fail;
4796     }
4797     {
4798         arg3 = (long)(SWIG_As_long(obj2));
4799         if (SWIG_arg_fail(3)) SWIG_fail;
4800     }
4801     {
4802         arg4 = wxString_in_helper(obj3);
4803         if (arg4 == NULL) SWIG_fail;
4804         temp4 = true;
4805     }
4806     {
4807         PyThreadState* __tstate = wxPyBeginAllowThreads();
4808         (arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
4809
4810         wxPyEndAllowThreads(__tstate);
4811         if (PyErr_Occurred()) SWIG_fail;
4812     }
4813     Py_INCREF(Py_None); resultobj = Py_None;
4814     {
4815         if (temp4)
4816         delete arg4;
4817     }
4818     return resultobj;
4819     fail:
4820     {
4821         if (temp4)
4822         delete arg4;
4823     }
4824     return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_ComboBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4829     PyObject *resultobj;
4830     wxComboBox *arg1 = (wxComboBox *) 0 ;
4831     int arg2 ;
4832     PyObject * obj0 = 0 ;
4833     PyObject * obj1 = 0 ;
4834     char *kwnames[] = {
4835         (char *) "self",(char *) "n", NULL
4836     };
4837
4838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
4839     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4840     if (SWIG_arg_fail(1)) SWIG_fail;
4841     {
4842         arg2 = (int)(SWIG_As_int(obj1));
4843         if (SWIG_arg_fail(2)) SWIG_fail;
4844     }
4845     {
4846         PyThreadState* __tstate = wxPyBeginAllowThreads();
4847         (arg1)->SetSelection(arg2);
4848
4849         wxPyEndAllowThreads(__tstate);
4850         if (PyErr_Occurred()) SWIG_fail;
4851     }
4852     Py_INCREF(Py_None); resultobj = Py_None;
4853     return resultobj;
4854     fail:
4855     return NULL;
4856 }
4857
4858
4859 static PyObject *_wrap_ComboBox_SetMark(PyObject *, PyObject *args, PyObject *kwargs) {
4860     PyObject *resultobj;
4861     wxComboBox *arg1 = (wxComboBox *) 0 ;
4862     long arg2 ;
4863     long arg3 ;
4864     PyObject * obj0 = 0 ;
4865     PyObject * obj1 = 0 ;
4866     PyObject * obj2 = 0 ;
4867     char *kwnames[] = {
4868         (char *) "self",(char *) "from",(char *) "to", NULL
4869     };
4870
4871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_SetMark",kwnames,&obj0,&obj1,&obj2)) goto fail;
4872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4873     if (SWIG_arg_fail(1)) SWIG_fail;
4874     {
4875         arg2 = (long)(SWIG_As_long(obj1));
4876         if (SWIG_arg_fail(2)) SWIG_fail;
4877     }
4878     {
4879         arg3 = (long)(SWIG_As_long(obj2));
4880         if (SWIG_arg_fail(3)) SWIG_fail;
4881     }
4882     {
4883         PyThreadState* __tstate = wxPyBeginAllowThreads();
4884         (arg1)->SetSelection(arg2,arg3);
4885
4886         wxPyEndAllowThreads(__tstate);
4887         if (PyErr_Occurred()) SWIG_fail;
4888     }
4889     Py_INCREF(Py_None); resultobj = Py_None;
4890     return resultobj;
4891     fail:
4892     return NULL;
4893 }
4894
4895
4896 static PyObject *_wrap_ComboBox_GetMark(PyObject *, PyObject *args, PyObject *kwargs) {
4897     PyObject *resultobj;
4898     wxComboBox *arg1 = (wxComboBox *) 0 ;
4899     long *arg2 = (long *) 0 ;
4900     long *arg3 = (long *) 0 ;
4901     long temp2 ;
4902     int res2 = 0 ;
4903     long temp3 ;
4904     int res3 = 0 ;
4905     PyObject * obj0 = 0 ;
4906     char *kwnames[] = {
4907         (char *) "self", NULL
4908     };
4909
4910     arg2 = &temp2; res2 = SWIG_NEWOBJ;
4911     arg3 = &temp3; res3 = SWIG_NEWOBJ;
4912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_GetMark",kwnames,&obj0)) goto fail;
4913     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4914     if (SWIG_arg_fail(1)) SWIG_fail;
4915     {
4916         PyThreadState* __tstate = wxPyBeginAllowThreads();
4917         (arg1)->GetSelection(arg2,arg3);
4918
4919         wxPyEndAllowThreads(__tstate);
4920         if (PyErr_Occurred()) SWIG_fail;
4921     }
4922     Py_INCREF(Py_None); resultobj = Py_None;
4923     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4924     SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
4925     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
4926     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
4927     return resultobj;
4928     fail:
4929     return NULL;
4930 }
4931
4932
4933 static PyObject *_wrap_ComboBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
4934     PyObject *resultobj;
4935     wxComboBox *arg1 = (wxComboBox *) 0 ;
4936     wxString *arg2 = 0 ;
4937     bool result;
4938     bool temp2 = false ;
4939     PyObject * obj0 = 0 ;
4940     PyObject * obj1 = 0 ;
4941     char *kwnames[] = {
4942         (char *) "self",(char *) "string", NULL
4943     };
4944
4945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
4946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4947     if (SWIG_arg_fail(1)) SWIG_fail;
4948     {
4949         arg2 = wxString_in_helper(obj1);
4950         if (arg2 == NULL) SWIG_fail;
4951         temp2 = true;
4952     }
4953     {
4954         PyThreadState* __tstate = wxPyBeginAllowThreads();
4955         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
4956
4957         wxPyEndAllowThreads(__tstate);
4958         if (PyErr_Occurred()) SWIG_fail;
4959     }
4960     {
4961         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4962     }
4963     {
4964         if (temp2)
4965         delete arg2;
4966     }
4967     return resultobj;
4968     fail:
4969     {
4970         if (temp2)
4971         delete arg2;
4972     }
4973     return NULL;
4974 }
4975
4976
4977 static PyObject *_wrap_ComboBox_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
4978     PyObject *resultobj;
4979     wxComboBox *arg1 = (wxComboBox *) 0 ;
4980     int arg2 ;
4981     wxString *arg3 = 0 ;
4982     bool temp3 = false ;
4983     PyObject * obj0 = 0 ;
4984     PyObject * obj1 = 0 ;
4985     PyObject * obj2 = 0 ;
4986     char *kwnames[] = {
4987         (char *) "self",(char *) "n",(char *) "string", NULL
4988     };
4989
4990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
4991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
4992     if (SWIG_arg_fail(1)) SWIG_fail;
4993     {
4994         arg2 = (int)(SWIG_As_int(obj1));
4995         if (SWIG_arg_fail(2)) SWIG_fail;
4996     }
4997     {
4998         arg3 = wxString_in_helper(obj2);
4999         if (arg3 == NULL) SWIG_fail;
5000         temp3 = true;
5001     }
5002     {
5003         PyThreadState* __tstate = wxPyBeginAllowThreads();
5004         (arg1)->SetString(arg2,(wxString const &)*arg3);
5005
5006         wxPyEndAllowThreads(__tstate);
5007         if (PyErr_Occurred()) SWIG_fail;
5008     }
5009     Py_INCREF(Py_None); resultobj = Py_None;
5010     {
5011         if (temp3)
5012         delete arg3;
5013     }
5014     return resultobj;
5015     fail:
5016     {
5017         if (temp3)
5018         delete arg3;
5019     }
5020     return NULL;
5021 }
5022
5023
5024 static PyObject *_wrap_ComboBox_SetEditable(PyObject *, PyObject *args, PyObject *kwargs) {
5025     PyObject *resultobj;
5026     wxComboBox *arg1 = (wxComboBox *) 0 ;
5027     bool arg2 ;
5028     PyObject * obj0 = 0 ;
5029     PyObject * obj1 = 0 ;
5030     char *kwnames[] = {
5031         (char *) "self",(char *) "editable", NULL
5032     };
5033
5034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetEditable",kwnames,&obj0,&obj1)) goto fail;
5035     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5036     if (SWIG_arg_fail(1)) SWIG_fail;
5037     {
5038         arg2 = (bool)(SWIG_As_bool(obj1));
5039         if (SWIG_arg_fail(2)) SWIG_fail;
5040     }
5041     {
5042         PyThreadState* __tstate = wxPyBeginAllowThreads();
5043         (arg1)->SetEditable(arg2);
5044
5045         wxPyEndAllowThreads(__tstate);
5046         if (PyErr_Occurred()) SWIG_fail;
5047     }
5048     Py_INCREF(Py_None); resultobj = Py_None;
5049     return resultobj;
5050     fail:
5051     return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_ComboBox_SetInsertionPointEnd(PyObject *, PyObject *args, PyObject *kwargs) {
5056     PyObject *resultobj;
5057     wxComboBox *arg1 = (wxComboBox *) 0 ;
5058     PyObject * obj0 = 0 ;
5059     char *kwnames[] = {
5060         (char *) "self", NULL
5061     };
5062
5063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_SetInsertionPointEnd",kwnames,&obj0)) goto fail;
5064     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5065     if (SWIG_arg_fail(1)) SWIG_fail;
5066     {
5067         PyThreadState* __tstate = wxPyBeginAllowThreads();
5068         (arg1)->SetInsertionPointEnd();
5069
5070         wxPyEndAllowThreads(__tstate);
5071         if (PyErr_Occurred()) SWIG_fail;
5072     }
5073     Py_INCREF(Py_None); resultobj = Py_None;
5074     return resultobj;
5075     fail:
5076     return NULL;
5077 }
5078
5079
5080 static PyObject *_wrap_ComboBox_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
5081     PyObject *resultobj;
5082     wxComboBox *arg1 = (wxComboBox *) 0 ;
5083     long arg2 ;
5084     long arg3 ;
5085     PyObject * obj0 = 0 ;
5086     PyObject * obj1 = 0 ;
5087     PyObject * obj2 = 0 ;
5088     char *kwnames[] = {
5089         (char *) "self",(char *) "from",(char *) "to", NULL
5090     };
5091
5092     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_Remove",kwnames,&obj0,&obj1,&obj2)) goto fail;
5093     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5094     if (SWIG_arg_fail(1)) SWIG_fail;
5095     {
5096         arg2 = (long)(SWIG_As_long(obj1));
5097         if (SWIG_arg_fail(2)) SWIG_fail;
5098     }
5099     {
5100         arg3 = (long)(SWIG_As_long(obj2));
5101         if (SWIG_arg_fail(3)) SWIG_fail;
5102     }
5103     {
5104         PyThreadState* __tstate = wxPyBeginAllowThreads();
5105         (arg1)->Remove(arg2,arg3);
5106
5107         wxPyEndAllowThreads(__tstate);
5108         if (PyErr_Occurred()) SWIG_fail;
5109     }
5110     Py_INCREF(Py_None); resultobj = Py_None;
5111     return resultobj;
5112     fail:
5113     return NULL;
5114 }
5115
5116
5117 static PyObject *_wrap_ComboBox_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
5118     PyObject *resultobj;
5119     wxComboBox *arg1 = (wxComboBox *) 0 ;
5120     bool result;
5121     PyObject * obj0 = 0 ;
5122     char *kwnames[] = {
5123         (char *) "self", NULL
5124     };
5125
5126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_IsEditable",kwnames,&obj0)) goto fail;
5127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5128     if (SWIG_arg_fail(1)) SWIG_fail;
5129     {
5130         PyThreadState* __tstate = wxPyBeginAllowThreads();
5131         result = (bool)((wxComboBox const *)arg1)->IsEditable();
5132
5133         wxPyEndAllowThreads(__tstate);
5134         if (PyErr_Occurred()) SWIG_fail;
5135     }
5136     {
5137         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5138     }
5139     return resultobj;
5140     fail:
5141     return NULL;
5142 }
5143
5144
5145 static PyObject *_wrap_ComboBox_Undo(PyObject *, PyObject *args, PyObject *kwargs) {
5146     PyObject *resultobj;
5147     wxComboBox *arg1 = (wxComboBox *) 0 ;
5148     PyObject * obj0 = 0 ;
5149     char *kwnames[] = {
5150         (char *) "self", NULL
5151     };
5152
5153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Undo",kwnames,&obj0)) goto fail;
5154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5155     if (SWIG_arg_fail(1)) SWIG_fail;
5156     {
5157         PyThreadState* __tstate = wxPyBeginAllowThreads();
5158         (arg1)->Undo();
5159
5160         wxPyEndAllowThreads(__tstate);
5161         if (PyErr_Occurred()) SWIG_fail;
5162     }
5163     Py_INCREF(Py_None); resultobj = Py_None;
5164     return resultobj;
5165     fail:
5166     return NULL;
5167 }
5168
5169
5170 static PyObject *_wrap_ComboBox_Redo(PyObject *, PyObject *args, PyObject *kwargs) {
5171     PyObject *resultobj;
5172     wxComboBox *arg1 = (wxComboBox *) 0 ;
5173     PyObject * obj0 = 0 ;
5174     char *kwnames[] = {
5175         (char *) "self", NULL
5176     };
5177
5178     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_Redo",kwnames,&obj0)) goto fail;
5179     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5180     if (SWIG_arg_fail(1)) SWIG_fail;
5181     {
5182         PyThreadState* __tstate = wxPyBeginAllowThreads();
5183         (arg1)->Redo();
5184
5185         wxPyEndAllowThreads(__tstate);
5186         if (PyErr_Occurred()) SWIG_fail;
5187     }
5188     Py_INCREF(Py_None); resultobj = Py_None;
5189     return resultobj;
5190     fail:
5191     return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_ComboBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
5196     PyObject *resultobj;
5197     wxComboBox *arg1 = (wxComboBox *) 0 ;
5198     PyObject * obj0 = 0 ;
5199     char *kwnames[] = {
5200         (char *) "self", NULL
5201     };
5202
5203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_SelectAll",kwnames,&obj0)) goto fail;
5204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5205     if (SWIG_arg_fail(1)) SWIG_fail;
5206     {
5207         PyThreadState* __tstate = wxPyBeginAllowThreads();
5208         (arg1)->SelectAll();
5209
5210         wxPyEndAllowThreads(__tstate);
5211         if (PyErr_Occurred()) SWIG_fail;
5212     }
5213     Py_INCREF(Py_None); resultobj = Py_None;
5214     return resultobj;
5215     fail:
5216     return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_ComboBox_CanCopy(PyObject *, PyObject *args, PyObject *kwargs) {
5221     PyObject *resultobj;
5222     wxComboBox *arg1 = (wxComboBox *) 0 ;
5223     bool result;
5224     PyObject * obj0 = 0 ;
5225     char *kwnames[] = {
5226         (char *) "self", NULL
5227     };
5228
5229     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanCopy",kwnames,&obj0)) goto fail;
5230     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5231     if (SWIG_arg_fail(1)) SWIG_fail;
5232     {
5233         PyThreadState* __tstate = wxPyBeginAllowThreads();
5234         result = (bool)((wxComboBox const *)arg1)->CanCopy();
5235
5236         wxPyEndAllowThreads(__tstate);
5237         if (PyErr_Occurred()) SWIG_fail;
5238     }
5239     {
5240         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5241     }
5242     return resultobj;
5243     fail:
5244     return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_ComboBox_CanCut(PyObject *, PyObject *args, PyObject *kwargs) {
5249     PyObject *resultobj;
5250     wxComboBox *arg1 = (wxComboBox *) 0 ;
5251     bool result;
5252     PyObject * obj0 = 0 ;
5253     char *kwnames[] = {
5254         (char *) "self", NULL
5255     };
5256
5257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanCut",kwnames,&obj0)) goto fail;
5258     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5259     if (SWIG_arg_fail(1)) SWIG_fail;
5260     {
5261         PyThreadState* __tstate = wxPyBeginAllowThreads();
5262         result = (bool)((wxComboBox const *)arg1)->CanCut();
5263
5264         wxPyEndAllowThreads(__tstate);
5265         if (PyErr_Occurred()) SWIG_fail;
5266     }
5267     {
5268         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5269     }
5270     return resultobj;
5271     fail:
5272     return NULL;
5273 }
5274
5275
5276 static PyObject *_wrap_ComboBox_CanPaste(PyObject *, PyObject *args, PyObject *kwargs) {
5277     PyObject *resultobj;
5278     wxComboBox *arg1 = (wxComboBox *) 0 ;
5279     bool result;
5280     PyObject * obj0 = 0 ;
5281     char *kwnames[] = {
5282         (char *) "self", NULL
5283     };
5284
5285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanPaste",kwnames,&obj0)) goto fail;
5286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5287     if (SWIG_arg_fail(1)) SWIG_fail;
5288     {
5289         PyThreadState* __tstate = wxPyBeginAllowThreads();
5290         result = (bool)((wxComboBox const *)arg1)->CanPaste();
5291
5292         wxPyEndAllowThreads(__tstate);
5293         if (PyErr_Occurred()) SWIG_fail;
5294     }
5295     {
5296         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5297     }
5298     return resultobj;
5299     fail:
5300     return NULL;
5301 }
5302
5303
5304 static PyObject *_wrap_ComboBox_CanUndo(PyObject *, PyObject *args, PyObject *kwargs) {
5305     PyObject *resultobj;
5306     wxComboBox *arg1 = (wxComboBox *) 0 ;
5307     bool result;
5308     PyObject * obj0 = 0 ;
5309     char *kwnames[] = {
5310         (char *) "self", NULL
5311     };
5312
5313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanUndo",kwnames,&obj0)) goto fail;
5314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5315     if (SWIG_arg_fail(1)) SWIG_fail;
5316     {
5317         PyThreadState* __tstate = wxPyBeginAllowThreads();
5318         result = (bool)((wxComboBox const *)arg1)->CanUndo();
5319
5320         wxPyEndAllowThreads(__tstate);
5321         if (PyErr_Occurred()) SWIG_fail;
5322     }
5323     {
5324         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5325     }
5326     return resultobj;
5327     fail:
5328     return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_ComboBox_CanRedo(PyObject *, PyObject *args, PyObject *kwargs) {
5333     PyObject *resultobj;
5334     wxComboBox *arg1 = (wxComboBox *) 0 ;
5335     bool result;
5336     PyObject * obj0 = 0 ;
5337     char *kwnames[] = {
5338         (char *) "self", NULL
5339     };
5340
5341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ComboBox_CanRedo",kwnames,&obj0)) goto fail;
5342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxComboBox, SWIG_POINTER_EXCEPTION | 0);
5343     if (SWIG_arg_fail(1)) SWIG_fail;
5344     {
5345         PyThreadState* __tstate = wxPyBeginAllowThreads();
5346         result = (bool)((wxComboBox const *)arg1)->CanRedo();
5347
5348         wxPyEndAllowThreads(__tstate);
5349         if (PyErr_Occurred()) SWIG_fail;
5350     }
5351     {
5352         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5353     }
5354     return resultobj;
5355     fail:
5356     return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_ComboBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5361     PyObject *resultobj;
5362     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5363     wxVisualAttributes result;
5364     PyObject * obj0 = 0 ;
5365     char *kwnames[] = {
5366         (char *) "variant", NULL
5367     };
5368
5369     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ComboBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5370     if (obj0) {
5371         {
5372             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5373             if (SWIG_arg_fail(1)) SWIG_fail;
5374         }
5375     }
5376     {
5377         if (!wxPyCheckForApp()) SWIG_fail;
5378         PyThreadState* __tstate = wxPyBeginAllowThreads();
5379         result = wxComboBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
5380
5381         wxPyEndAllowThreads(__tstate);
5382         if (PyErr_Occurred()) SWIG_fail;
5383     }
5384     {
5385         wxVisualAttributes * resultptr;
5386         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5387         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5388     }
5389     return resultobj;
5390     fail:
5391     return NULL;
5392 }
5393
5394
5395 static PyObject * ComboBox_swigregister(PyObject *, PyObject *args) {
5396     PyObject *obj;
5397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5398     SWIG_TypeClientData(SWIGTYPE_p_wxComboBox, obj);
5399     Py_INCREF(obj);
5400     return Py_BuildValue((char *)"");
5401 }
5402 static int _wrap_GaugeNameStr_set(PyObject *) {
5403     PyErr_SetString(PyExc_TypeError,"Variable GaugeNameStr is read-only.");
5404     return 1;
5405 }
5406
5407
5408 static PyObject *_wrap_GaugeNameStr_get(void) {
5409     PyObject *pyobj;
5410
5411     {
5412 #if wxUSE_UNICODE
5413         pyobj = PyUnicode_FromWideChar((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
5414 #else
5415         pyobj = PyString_FromStringAndSize((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
5416 #endif
5417     }
5418     return pyobj;
5419 }
5420
5421
5422 static PyObject *_wrap_new_Gauge(PyObject *, PyObject *args, PyObject *kwargs) {
5423     PyObject *resultobj;
5424     wxWindow *arg1 = (wxWindow *) 0 ;
5425     int arg2 = (int) -1 ;
5426     int arg3 = (int) 100 ;
5427     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5428     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5429     wxSize const &arg5_defvalue = wxDefaultSize ;
5430     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5431     long arg6 = (long) wxGA_HORIZONTAL ;
5432     wxValidator const &arg7_defvalue = wxDefaultValidator ;
5433     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
5434     wxString const &arg8_defvalue = wxPyGaugeNameStr ;
5435     wxString *arg8 = (wxString *) &arg8_defvalue ;
5436     wxGauge *result;
5437     wxPoint temp4 ;
5438     wxSize temp5 ;
5439     bool temp8 = false ;
5440     PyObject * obj0 = 0 ;
5441     PyObject * obj1 = 0 ;
5442     PyObject * obj2 = 0 ;
5443     PyObject * obj3 = 0 ;
5444     PyObject * obj4 = 0 ;
5445     PyObject * obj5 = 0 ;
5446     PyObject * obj6 = 0 ;
5447     PyObject * obj7 = 0 ;
5448     char *kwnames[] = {
5449         (char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
5450     };
5451
5452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Gauge",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5454     if (SWIG_arg_fail(1)) SWIG_fail;
5455     if (obj1) {
5456         {
5457             arg2 = (int)(SWIG_As_int(obj1));
5458             if (SWIG_arg_fail(2)) SWIG_fail;
5459         }
5460     }
5461     if (obj2) {
5462         {
5463             arg3 = (int)(SWIG_As_int(obj2));
5464             if (SWIG_arg_fail(3)) SWIG_fail;
5465         }
5466     }
5467     if (obj3) {
5468         {
5469             arg4 = &temp4;
5470             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5471         }
5472     }
5473     if (obj4) {
5474         {
5475             arg5 = &temp5;
5476             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5477         }
5478     }
5479     if (obj5) {
5480         {
5481             arg6 = (long)(SWIG_As_long(obj5));
5482             if (SWIG_arg_fail(6)) SWIG_fail;
5483         }
5484     }
5485     if (obj6) {
5486         {
5487             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
5488             if (SWIG_arg_fail(7)) SWIG_fail;
5489             if (arg7 == NULL) {
5490                 SWIG_null_ref("wxValidator");
5491             }
5492             if (SWIG_arg_fail(7)) SWIG_fail;
5493         }
5494     }
5495     if (obj7) {
5496         {
5497             arg8 = wxString_in_helper(obj7);
5498             if (arg8 == NULL) SWIG_fail;
5499             temp8 = true;
5500         }
5501     }
5502     {
5503         if (!wxPyCheckForApp()) SWIG_fail;
5504         PyThreadState* __tstate = wxPyBeginAllowThreads();
5505         result = (wxGauge *)new wxGauge(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
5506
5507         wxPyEndAllowThreads(__tstate);
5508         if (PyErr_Occurred()) SWIG_fail;
5509     }
5510     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGauge, 1);
5511     {
5512         if (temp8)
5513         delete arg8;
5514     }
5515     return resultobj;
5516     fail:
5517     {
5518         if (temp8)
5519         delete arg8;
5520     }
5521     return NULL;
5522 }
5523
5524
5525 static PyObject *_wrap_new_PreGauge(PyObject *, PyObject *args, PyObject *kwargs) {
5526     PyObject *resultobj;
5527     wxGauge *result;
5528     char *kwnames[] = {
5529         NULL
5530     };
5531
5532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGauge",kwnames)) goto fail;
5533     {
5534         if (!wxPyCheckForApp()) SWIG_fail;
5535         PyThreadState* __tstate = wxPyBeginAllowThreads();
5536         result = (wxGauge *)new wxGauge();
5537
5538         wxPyEndAllowThreads(__tstate);
5539         if (PyErr_Occurred()) SWIG_fail;
5540     }
5541     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGauge, 1);
5542     return resultobj;
5543     fail:
5544     return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_Gauge_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5549     PyObject *resultobj;
5550     wxGauge *arg1 = (wxGauge *) 0 ;
5551     wxWindow *arg2 = (wxWindow *) 0 ;
5552     int arg3 = (int) -1 ;
5553     int arg4 = (int) 100 ;
5554     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5555     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5556     wxSize const &arg6_defvalue = wxDefaultSize ;
5557     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5558     long arg7 = (long) wxGA_HORIZONTAL ;
5559     wxValidator const &arg8_defvalue = wxDefaultValidator ;
5560     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
5561     wxString const &arg9_defvalue = wxPyGaugeNameStr ;
5562     wxString *arg9 = (wxString *) &arg9_defvalue ;
5563     bool result;
5564     wxPoint temp5 ;
5565     wxSize temp6 ;
5566     bool temp9 = false ;
5567     PyObject * obj0 = 0 ;
5568     PyObject * obj1 = 0 ;
5569     PyObject * obj2 = 0 ;
5570     PyObject * obj3 = 0 ;
5571     PyObject * obj4 = 0 ;
5572     PyObject * obj5 = 0 ;
5573     PyObject * obj6 = 0 ;
5574     PyObject * obj7 = 0 ;
5575     PyObject * obj8 = 0 ;
5576     char *kwnames[] = {
5577         (char *) "self",(char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
5578     };
5579
5580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Gauge_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5581     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5582     if (SWIG_arg_fail(1)) SWIG_fail;
5583     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5584     if (SWIG_arg_fail(2)) SWIG_fail;
5585     if (obj2) {
5586         {
5587             arg3 = (int)(SWIG_As_int(obj2));
5588             if (SWIG_arg_fail(3)) SWIG_fail;
5589         }
5590     }
5591     if (obj3) {
5592         {
5593             arg4 = (int)(SWIG_As_int(obj3));
5594             if (SWIG_arg_fail(4)) SWIG_fail;
5595         }
5596     }
5597     if (obj4) {
5598         {
5599             arg5 = &temp5;
5600             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5601         }
5602     }
5603     if (obj5) {
5604         {
5605             arg6 = &temp6;
5606             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5607         }
5608     }
5609     if (obj6) {
5610         {
5611             arg7 = (long)(SWIG_As_long(obj6));
5612             if (SWIG_arg_fail(7)) SWIG_fail;
5613         }
5614     }
5615     if (obj7) {
5616         {
5617             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
5618             if (SWIG_arg_fail(8)) SWIG_fail;
5619             if (arg8 == NULL) {
5620                 SWIG_null_ref("wxValidator");
5621             }
5622             if (SWIG_arg_fail(8)) SWIG_fail;
5623         }
5624     }
5625     if (obj8) {
5626         {
5627             arg9 = wxString_in_helper(obj8);
5628             if (arg9 == NULL) SWIG_fail;
5629             temp9 = true;
5630         }
5631     }
5632     {
5633         PyThreadState* __tstate = wxPyBeginAllowThreads();
5634         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
5635
5636         wxPyEndAllowThreads(__tstate);
5637         if (PyErr_Occurred()) SWIG_fail;
5638     }
5639     {
5640         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5641     }
5642     {
5643         if (temp9)
5644         delete arg9;
5645     }
5646     return resultobj;
5647     fail:
5648     {
5649         if (temp9)
5650         delete arg9;
5651     }
5652     return NULL;
5653 }
5654
5655
5656 static PyObject *_wrap_Gauge_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
5657     PyObject *resultobj;
5658     wxGauge *arg1 = (wxGauge *) 0 ;
5659     int arg2 ;
5660     PyObject * obj0 = 0 ;
5661     PyObject * obj1 = 0 ;
5662     char *kwnames[] = {
5663         (char *) "self",(char *) "range", NULL
5664     };
5665
5666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetRange",kwnames,&obj0,&obj1)) goto fail;
5667     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5668     if (SWIG_arg_fail(1)) SWIG_fail;
5669     {
5670         arg2 = (int)(SWIG_As_int(obj1));
5671         if (SWIG_arg_fail(2)) SWIG_fail;
5672     }
5673     {
5674         PyThreadState* __tstate = wxPyBeginAllowThreads();
5675         (arg1)->SetRange(arg2);
5676
5677         wxPyEndAllowThreads(__tstate);
5678         if (PyErr_Occurred()) SWIG_fail;
5679     }
5680     Py_INCREF(Py_None); resultobj = Py_None;
5681     return resultobj;
5682     fail:
5683     return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_Gauge_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
5688     PyObject *resultobj;
5689     wxGauge *arg1 = (wxGauge *) 0 ;
5690     int result;
5691     PyObject * obj0 = 0 ;
5692     char *kwnames[] = {
5693         (char *) "self", NULL
5694     };
5695
5696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetRange",kwnames,&obj0)) goto fail;
5697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5698     if (SWIG_arg_fail(1)) SWIG_fail;
5699     {
5700         PyThreadState* __tstate = wxPyBeginAllowThreads();
5701         result = (int)((wxGauge const *)arg1)->GetRange();
5702
5703         wxPyEndAllowThreads(__tstate);
5704         if (PyErr_Occurred()) SWIG_fail;
5705     }
5706     {
5707         resultobj = SWIG_From_int((int)(result));
5708     }
5709     return resultobj;
5710     fail:
5711     return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_Gauge_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5716     PyObject *resultobj;
5717     wxGauge *arg1 = (wxGauge *) 0 ;
5718     int arg2 ;
5719     PyObject * obj0 = 0 ;
5720     PyObject * obj1 = 0 ;
5721     char *kwnames[] = {
5722         (char *) "self",(char *) "pos", NULL
5723     };
5724
5725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetValue",kwnames,&obj0,&obj1)) goto fail;
5726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5727     if (SWIG_arg_fail(1)) SWIG_fail;
5728     {
5729         arg2 = (int)(SWIG_As_int(obj1));
5730         if (SWIG_arg_fail(2)) SWIG_fail;
5731     }
5732     {
5733         PyThreadState* __tstate = wxPyBeginAllowThreads();
5734         (arg1)->SetValue(arg2);
5735
5736         wxPyEndAllowThreads(__tstate);
5737         if (PyErr_Occurred()) SWIG_fail;
5738     }
5739     Py_INCREF(Py_None); resultobj = Py_None;
5740     return resultobj;
5741     fail:
5742     return NULL;
5743 }
5744
5745
5746 static PyObject *_wrap_Gauge_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5747     PyObject *resultobj;
5748     wxGauge *arg1 = (wxGauge *) 0 ;
5749     int result;
5750     PyObject * obj0 = 0 ;
5751     char *kwnames[] = {
5752         (char *) "self", NULL
5753     };
5754
5755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetValue",kwnames,&obj0)) goto fail;
5756     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5757     if (SWIG_arg_fail(1)) SWIG_fail;
5758     {
5759         PyThreadState* __tstate = wxPyBeginAllowThreads();
5760         result = (int)((wxGauge const *)arg1)->GetValue();
5761
5762         wxPyEndAllowThreads(__tstate);
5763         if (PyErr_Occurred()) SWIG_fail;
5764     }
5765     {
5766         resultobj = SWIG_From_int((int)(result));
5767     }
5768     return resultobj;
5769     fail:
5770     return NULL;
5771 }
5772
5773
5774 static PyObject *_wrap_Gauge_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
5775     PyObject *resultobj;
5776     wxGauge *arg1 = (wxGauge *) 0 ;
5777     bool result;
5778     PyObject * obj0 = 0 ;
5779     char *kwnames[] = {
5780         (char *) "self", NULL
5781     };
5782
5783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_IsVertical",kwnames,&obj0)) goto fail;
5784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5785     if (SWIG_arg_fail(1)) SWIG_fail;
5786     {
5787         PyThreadState* __tstate = wxPyBeginAllowThreads();
5788         result = (bool)((wxGauge const *)arg1)->IsVertical();
5789
5790         wxPyEndAllowThreads(__tstate);
5791         if (PyErr_Occurred()) SWIG_fail;
5792     }
5793     {
5794         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5795     }
5796     return resultobj;
5797     fail:
5798     return NULL;
5799 }
5800
5801
5802 static PyObject *_wrap_Gauge_SetShadowWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5803     PyObject *resultobj;
5804     wxGauge *arg1 = (wxGauge *) 0 ;
5805     int arg2 ;
5806     PyObject * obj0 = 0 ;
5807     PyObject * obj1 = 0 ;
5808     char *kwnames[] = {
5809         (char *) "self",(char *) "w", NULL
5810     };
5811
5812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetShadowWidth",kwnames,&obj0,&obj1)) goto fail;
5813     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5814     if (SWIG_arg_fail(1)) SWIG_fail;
5815     {
5816         arg2 = (int)(SWIG_As_int(obj1));
5817         if (SWIG_arg_fail(2)) SWIG_fail;
5818     }
5819     {
5820         PyThreadState* __tstate = wxPyBeginAllowThreads();
5821         (arg1)->SetShadowWidth(arg2);
5822
5823         wxPyEndAllowThreads(__tstate);
5824         if (PyErr_Occurred()) SWIG_fail;
5825     }
5826     Py_INCREF(Py_None); resultobj = Py_None;
5827     return resultobj;
5828     fail:
5829     return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_Gauge_GetShadowWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5834     PyObject *resultobj;
5835     wxGauge *arg1 = (wxGauge *) 0 ;
5836     int result;
5837     PyObject * obj0 = 0 ;
5838     char *kwnames[] = {
5839         (char *) "self", NULL
5840     };
5841
5842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetShadowWidth",kwnames,&obj0)) goto fail;
5843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5844     if (SWIG_arg_fail(1)) SWIG_fail;
5845     {
5846         PyThreadState* __tstate = wxPyBeginAllowThreads();
5847         result = (int)((wxGauge const *)arg1)->GetShadowWidth();
5848
5849         wxPyEndAllowThreads(__tstate);
5850         if (PyErr_Occurred()) SWIG_fail;
5851     }
5852     {
5853         resultobj = SWIG_From_int((int)(result));
5854     }
5855     return resultobj;
5856     fail:
5857     return NULL;
5858 }
5859
5860
5861 static PyObject *_wrap_Gauge_SetBezelFace(PyObject *, PyObject *args, PyObject *kwargs) {
5862     PyObject *resultobj;
5863     wxGauge *arg1 = (wxGauge *) 0 ;
5864     int arg2 ;
5865     PyObject * obj0 = 0 ;
5866     PyObject * obj1 = 0 ;
5867     char *kwnames[] = {
5868         (char *) "self",(char *) "w", NULL
5869     };
5870
5871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetBezelFace",kwnames,&obj0,&obj1)) goto fail;
5872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5873     if (SWIG_arg_fail(1)) SWIG_fail;
5874     {
5875         arg2 = (int)(SWIG_As_int(obj1));
5876         if (SWIG_arg_fail(2)) SWIG_fail;
5877     }
5878     {
5879         PyThreadState* __tstate = wxPyBeginAllowThreads();
5880         (arg1)->SetBezelFace(arg2);
5881
5882         wxPyEndAllowThreads(__tstate);
5883         if (PyErr_Occurred()) SWIG_fail;
5884     }
5885     Py_INCREF(Py_None); resultobj = Py_None;
5886     return resultobj;
5887     fail:
5888     return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_Gauge_GetBezelFace(PyObject *, PyObject *args, PyObject *kwargs) {
5893     PyObject *resultobj;
5894     wxGauge *arg1 = (wxGauge *) 0 ;
5895     int result;
5896     PyObject * obj0 = 0 ;
5897     char *kwnames[] = {
5898         (char *) "self", NULL
5899     };
5900
5901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Gauge_GetBezelFace",kwnames,&obj0)) goto fail;
5902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGauge, SWIG_POINTER_EXCEPTION | 0);
5903     if (SWIG_arg_fail(1)) SWIG_fail;
5904     {
5905         PyThreadState* __tstate = wxPyBeginAllowThreads();
5906         result = (int)((wxGauge const *)arg1)->GetBezelFace();
5907
5908         wxPyEndAllowThreads(__tstate);
5909         if (PyErr_Occurred()) SWIG_fail;
5910     }
5911     {
5912         resultobj = SWIG_From_int((int)(result));
5913     }
5914     return resultobj;
5915     fail:
5916     return NULL;
5917 }
5918
5919
5920 static PyObject *_wrap_Gauge_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5921     PyObject *resultobj;
5922     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5923     wxVisualAttributes result;
5924     PyObject * obj0 = 0 ;
5925     char *kwnames[] = {
5926         (char *) "variant", NULL
5927     };
5928
5929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Gauge_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5930     if (obj0) {
5931         {
5932             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5933             if (SWIG_arg_fail(1)) SWIG_fail;
5934         }
5935     }
5936     {
5937         if (!wxPyCheckForApp()) SWIG_fail;
5938         PyThreadState* __tstate = wxPyBeginAllowThreads();
5939         result = wxGauge::GetClassDefaultAttributes((wxWindowVariant )arg1);
5940
5941         wxPyEndAllowThreads(__tstate);
5942         if (PyErr_Occurred()) SWIG_fail;
5943     }
5944     {
5945         wxVisualAttributes * resultptr;
5946         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5947         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5948     }
5949     return resultobj;
5950     fail:
5951     return NULL;
5952 }
5953
5954
5955 static PyObject * Gauge_swigregister(PyObject *, PyObject *args) {
5956     PyObject *obj;
5957     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5958     SWIG_TypeClientData(SWIGTYPE_p_wxGauge, obj);
5959     Py_INCREF(obj);
5960     return Py_BuildValue((char *)"");
5961 }
5962 static int _wrap_StaticBitmapNameStr_set(PyObject *) {
5963     PyErr_SetString(PyExc_TypeError,"Variable StaticBitmapNameStr is read-only.");
5964     return 1;
5965 }
5966
5967
5968 static PyObject *_wrap_StaticBitmapNameStr_get(void) {
5969     PyObject *pyobj;
5970
5971     {
5972 #if wxUSE_UNICODE
5973         pyobj = PyUnicode_FromWideChar((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
5974 #else
5975         pyobj = PyString_FromStringAndSize((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
5976 #endif
5977     }
5978     return pyobj;
5979 }
5980
5981
5982 static int _wrap_StaticBoxNameStr_set(PyObject *) {
5983     PyErr_SetString(PyExc_TypeError,"Variable StaticBoxNameStr is read-only.");
5984     return 1;
5985 }
5986
5987
5988 static PyObject *_wrap_StaticBoxNameStr_get(void) {
5989     PyObject *pyobj;
5990
5991     {
5992 #if wxUSE_UNICODE
5993         pyobj = PyUnicode_FromWideChar((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
5994 #else
5995         pyobj = PyString_FromStringAndSize((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
5996 #endif
5997     }
5998     return pyobj;
5999 }
6000
6001
6002 static int _wrap_StaticTextNameStr_set(PyObject *) {
6003     PyErr_SetString(PyExc_TypeError,"Variable StaticTextNameStr is read-only.");
6004     return 1;
6005 }
6006
6007
6008 static PyObject *_wrap_StaticTextNameStr_get(void) {
6009     PyObject *pyobj;
6010
6011     {
6012 #if wxUSE_UNICODE
6013         pyobj = PyUnicode_FromWideChar((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
6014 #else
6015         pyobj = PyString_FromStringAndSize((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
6016 #endif
6017     }
6018     return pyobj;
6019 }
6020
6021
6022 static PyObject *_wrap_new_StaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
6023     PyObject *resultobj;
6024     wxWindow *arg1 = (wxWindow *) 0 ;
6025     int arg2 = (int) -1 ;
6026     wxString const &arg3_defvalue = wxPyEmptyString ;
6027     wxString *arg3 = (wxString *) &arg3_defvalue ;
6028     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6029     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6030     wxSize const &arg5_defvalue = wxDefaultSize ;
6031     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6032     long arg6 = (long) 0 ;
6033     wxString const &arg7_defvalue = wxPyStaticBoxNameStr ;
6034     wxString *arg7 = (wxString *) &arg7_defvalue ;
6035     wxStaticBox *result;
6036     bool temp3 = false ;
6037     wxPoint temp4 ;
6038     wxSize temp5 ;
6039     bool temp7 = false ;
6040     PyObject * obj0 = 0 ;
6041     PyObject * obj1 = 0 ;
6042     PyObject * obj2 = 0 ;
6043     PyObject * obj3 = 0 ;
6044     PyObject * obj4 = 0 ;
6045     PyObject * obj5 = 0 ;
6046     PyObject * obj6 = 0 ;
6047     char *kwnames[] = {
6048         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6049     };
6050
6051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6053     if (SWIG_arg_fail(1)) SWIG_fail;
6054     if (obj1) {
6055         {
6056             arg2 = (int)(SWIG_As_int(obj1));
6057             if (SWIG_arg_fail(2)) SWIG_fail;
6058         }
6059     }
6060     if (obj2) {
6061         {
6062             arg3 = wxString_in_helper(obj2);
6063             if (arg3 == NULL) SWIG_fail;
6064             temp3 = true;
6065         }
6066     }
6067     if (obj3) {
6068         {
6069             arg4 = &temp4;
6070             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6071         }
6072     }
6073     if (obj4) {
6074         {
6075             arg5 = &temp5;
6076             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6077         }
6078     }
6079     if (obj5) {
6080         {
6081             arg6 = (long)(SWIG_As_long(obj5));
6082             if (SWIG_arg_fail(6)) SWIG_fail;
6083         }
6084     }
6085     if (obj6) {
6086         {
6087             arg7 = wxString_in_helper(obj6);
6088             if (arg7 == NULL) SWIG_fail;
6089             temp7 = true;
6090         }
6091     }
6092     {
6093         if (!wxPyCheckForApp()) SWIG_fail;
6094         PyThreadState* __tstate = wxPyBeginAllowThreads();
6095         result = (wxStaticBox *)new wxStaticBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6096
6097         wxPyEndAllowThreads(__tstate);
6098         if (PyErr_Occurred()) SWIG_fail;
6099     }
6100     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBox, 1);
6101     {
6102         if (temp3)
6103         delete arg3;
6104     }
6105     {
6106         if (temp7)
6107         delete arg7;
6108     }
6109     return resultobj;
6110     fail:
6111     {
6112         if (temp3)
6113         delete arg3;
6114     }
6115     {
6116         if (temp7)
6117         delete arg7;
6118     }
6119     return NULL;
6120 }
6121
6122
6123 static PyObject *_wrap_new_PreStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
6124     PyObject *resultobj;
6125     wxStaticBox *result;
6126     char *kwnames[] = {
6127         NULL
6128     };
6129
6130     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticBox",kwnames)) goto fail;
6131     {
6132         if (!wxPyCheckForApp()) SWIG_fail;
6133         PyThreadState* __tstate = wxPyBeginAllowThreads();
6134         result = (wxStaticBox *)new wxStaticBox();
6135
6136         wxPyEndAllowThreads(__tstate);
6137         if (PyErr_Occurred()) SWIG_fail;
6138     }
6139     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBox, 1);
6140     return resultobj;
6141     fail:
6142     return NULL;
6143 }
6144
6145
6146 static PyObject *_wrap_StaticBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6147     PyObject *resultobj;
6148     wxStaticBox *arg1 = (wxStaticBox *) 0 ;
6149     wxWindow *arg2 = (wxWindow *) 0 ;
6150     int arg3 = (int) -1 ;
6151     wxString const &arg4_defvalue = wxPyEmptyString ;
6152     wxString *arg4 = (wxString *) &arg4_defvalue ;
6153     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6154     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6155     wxSize const &arg6_defvalue = wxDefaultSize ;
6156     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6157     long arg7 = (long) 0 ;
6158     wxString const &arg8_defvalue = wxPyStaticBoxNameStr ;
6159     wxString *arg8 = (wxString *) &arg8_defvalue ;
6160     bool result;
6161     bool temp4 = false ;
6162     wxPoint temp5 ;
6163     wxSize temp6 ;
6164     bool temp8 = false ;
6165     PyObject * obj0 = 0 ;
6166     PyObject * obj1 = 0 ;
6167     PyObject * obj2 = 0 ;
6168     PyObject * obj3 = 0 ;
6169     PyObject * obj4 = 0 ;
6170     PyObject * obj5 = 0 ;
6171     PyObject * obj6 = 0 ;
6172     PyObject * obj7 = 0 ;
6173     char *kwnames[] = {
6174         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6175     };
6176
6177     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6178     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
6179     if (SWIG_arg_fail(1)) SWIG_fail;
6180     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6181     if (SWIG_arg_fail(2)) SWIG_fail;
6182     if (obj2) {
6183         {
6184             arg3 = (int)(SWIG_As_int(obj2));
6185             if (SWIG_arg_fail(3)) SWIG_fail;
6186         }
6187     }
6188     if (obj3) {
6189         {
6190             arg4 = wxString_in_helper(obj3);
6191             if (arg4 == NULL) SWIG_fail;
6192             temp4 = true;
6193         }
6194     }
6195     if (obj4) {
6196         {
6197             arg5 = &temp5;
6198             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6199         }
6200     }
6201     if (obj5) {
6202         {
6203             arg6 = &temp6;
6204             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6205         }
6206     }
6207     if (obj6) {
6208         {
6209             arg7 = (long)(SWIG_As_long(obj6));
6210             if (SWIG_arg_fail(7)) SWIG_fail;
6211         }
6212     }
6213     if (obj7) {
6214         {
6215             arg8 = wxString_in_helper(obj7);
6216             if (arg8 == NULL) SWIG_fail;
6217             temp8 = true;
6218         }
6219     }
6220     {
6221         PyThreadState* __tstate = wxPyBeginAllowThreads();
6222         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6223
6224         wxPyEndAllowThreads(__tstate);
6225         if (PyErr_Occurred()) SWIG_fail;
6226     }
6227     {
6228         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6229     }
6230     {
6231         if (temp4)
6232         delete arg4;
6233     }
6234     {
6235         if (temp8)
6236         delete arg8;
6237     }
6238     return resultobj;
6239     fail:
6240     {
6241         if (temp4)
6242         delete arg4;
6243     }
6244     {
6245         if (temp8)
6246         delete arg8;
6247     }
6248     return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_StaticBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6253     PyObject *resultobj;
6254     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6255     wxVisualAttributes result;
6256     PyObject * obj0 = 0 ;
6257     char *kwnames[] = {
6258         (char *) "variant", NULL
6259     };
6260
6261     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6262     if (obj0) {
6263         {
6264             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6265             if (SWIG_arg_fail(1)) SWIG_fail;
6266         }
6267     }
6268     {
6269         if (!wxPyCheckForApp()) SWIG_fail;
6270         PyThreadState* __tstate = wxPyBeginAllowThreads();
6271         result = wxStaticBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
6272
6273         wxPyEndAllowThreads(__tstate);
6274         if (PyErr_Occurred()) SWIG_fail;
6275     }
6276     {
6277         wxVisualAttributes * resultptr;
6278         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6279         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6280     }
6281     return resultobj;
6282     fail:
6283     return NULL;
6284 }
6285
6286
6287 static PyObject * StaticBox_swigregister(PyObject *, PyObject *args) {
6288     PyObject *obj;
6289     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6290     SWIG_TypeClientData(SWIGTYPE_p_wxStaticBox, obj);
6291     Py_INCREF(obj);
6292     return Py_BuildValue((char *)"");
6293 }
6294 static PyObject *_wrap_new_StaticLine(PyObject *, PyObject *args, PyObject *kwargs) {
6295     PyObject *resultobj;
6296     wxWindow *arg1 = (wxWindow *) 0 ;
6297     int arg2 = (int) -1 ;
6298     wxPoint const &arg3_defvalue = wxDefaultPosition ;
6299     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
6300     wxSize const &arg4_defvalue = wxDefaultSize ;
6301     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
6302     long arg5 = (long) wxLI_HORIZONTAL ;
6303     wxString const &arg6_defvalue = wxPyStaticTextNameStr ;
6304     wxString *arg6 = (wxString *) &arg6_defvalue ;
6305     wxStaticLine *result;
6306     wxPoint temp3 ;
6307     wxSize temp4 ;
6308     bool temp6 = false ;
6309     PyObject * obj0 = 0 ;
6310     PyObject * obj1 = 0 ;
6311     PyObject * obj2 = 0 ;
6312     PyObject * obj3 = 0 ;
6313     PyObject * obj4 = 0 ;
6314     PyObject * obj5 = 0 ;
6315     char *kwnames[] = {
6316         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6317     };
6318
6319     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_StaticLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6320     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6321     if (SWIG_arg_fail(1)) SWIG_fail;
6322     if (obj1) {
6323         {
6324             arg2 = (int)(SWIG_As_int(obj1));
6325             if (SWIG_arg_fail(2)) SWIG_fail;
6326         }
6327     }
6328     if (obj2) {
6329         {
6330             arg3 = &temp3;
6331             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
6332         }
6333     }
6334     if (obj3) {
6335         {
6336             arg4 = &temp4;
6337             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
6338         }
6339     }
6340     if (obj4) {
6341         {
6342             arg5 = (long)(SWIG_As_long(obj4));
6343             if (SWIG_arg_fail(5)) SWIG_fail;
6344         }
6345     }
6346     if (obj5) {
6347         {
6348             arg6 = wxString_in_helper(obj5);
6349             if (arg6 == NULL) SWIG_fail;
6350             temp6 = true;
6351         }
6352     }
6353     {
6354         if (!wxPyCheckForApp()) SWIG_fail;
6355         PyThreadState* __tstate = wxPyBeginAllowThreads();
6356         result = (wxStaticLine *)new wxStaticLine(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
6357
6358         wxPyEndAllowThreads(__tstate);
6359         if (PyErr_Occurred()) SWIG_fail;
6360     }
6361     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticLine, 1);
6362     {
6363         if (temp6)
6364         delete arg6;
6365     }
6366     return resultobj;
6367     fail:
6368     {
6369         if (temp6)
6370         delete arg6;
6371     }
6372     return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_new_PreStaticLine(PyObject *, PyObject *args, PyObject *kwargs) {
6377     PyObject *resultobj;
6378     wxStaticLine *result;
6379     char *kwnames[] = {
6380         NULL
6381     };
6382
6383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticLine",kwnames)) goto fail;
6384     {
6385         if (!wxPyCheckForApp()) SWIG_fail;
6386         PyThreadState* __tstate = wxPyBeginAllowThreads();
6387         result = (wxStaticLine *)new wxStaticLine();
6388
6389         wxPyEndAllowThreads(__tstate);
6390         if (PyErr_Occurred()) SWIG_fail;
6391     }
6392     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticLine, 1);
6393     return resultobj;
6394     fail:
6395     return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_StaticLine_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6400     PyObject *resultobj;
6401     wxStaticLine *arg1 = (wxStaticLine *) 0 ;
6402     wxWindow *arg2 = (wxWindow *) 0 ;
6403     int arg3 = (int) -1 ;
6404     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6405     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6406     wxSize const &arg5_defvalue = wxDefaultSize ;
6407     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6408     long arg6 = (long) wxLI_HORIZONTAL ;
6409     wxString const &arg7_defvalue = wxPyStaticTextNameStr ;
6410     wxString *arg7 = (wxString *) &arg7_defvalue ;
6411     bool result;
6412     wxPoint temp4 ;
6413     wxSize temp5 ;
6414     bool temp7 = false ;
6415     PyObject * obj0 = 0 ;
6416     PyObject * obj1 = 0 ;
6417     PyObject * obj2 = 0 ;
6418     PyObject * obj3 = 0 ;
6419     PyObject * obj4 = 0 ;
6420     PyObject * obj5 = 0 ;
6421     PyObject * obj6 = 0 ;
6422     char *kwnames[] = {
6423         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6424     };
6425
6426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:StaticLine_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticLine, SWIG_POINTER_EXCEPTION | 0);
6428     if (SWIG_arg_fail(1)) SWIG_fail;
6429     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6430     if (SWIG_arg_fail(2)) SWIG_fail;
6431     if (obj2) {
6432         {
6433             arg3 = (int)(SWIG_As_int(obj2));
6434             if (SWIG_arg_fail(3)) SWIG_fail;
6435         }
6436     }
6437     if (obj3) {
6438         {
6439             arg4 = &temp4;
6440             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6441         }
6442     }
6443     if (obj4) {
6444         {
6445             arg5 = &temp5;
6446             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6447         }
6448     }
6449     if (obj5) {
6450         {
6451             arg6 = (long)(SWIG_As_long(obj5));
6452             if (SWIG_arg_fail(6)) SWIG_fail;
6453         }
6454     }
6455     if (obj6) {
6456         {
6457             arg7 = wxString_in_helper(obj6);
6458             if (arg7 == NULL) SWIG_fail;
6459             temp7 = true;
6460         }
6461     }
6462     {
6463         PyThreadState* __tstate = wxPyBeginAllowThreads();
6464         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6465
6466         wxPyEndAllowThreads(__tstate);
6467         if (PyErr_Occurred()) SWIG_fail;
6468     }
6469     {
6470         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6471     }
6472     {
6473         if (temp7)
6474         delete arg7;
6475     }
6476     return resultobj;
6477     fail:
6478     {
6479         if (temp7)
6480         delete arg7;
6481     }
6482     return NULL;
6483 }
6484
6485
6486 static PyObject *_wrap_StaticLine_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
6487     PyObject *resultobj;
6488     wxStaticLine *arg1 = (wxStaticLine *) 0 ;
6489     bool result;
6490     PyObject * obj0 = 0 ;
6491     char *kwnames[] = {
6492         (char *) "self", NULL
6493     };
6494
6495     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticLine_IsVertical",kwnames,&obj0)) goto fail;
6496     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticLine, SWIG_POINTER_EXCEPTION | 0);
6497     if (SWIG_arg_fail(1)) SWIG_fail;
6498     {
6499         PyThreadState* __tstate = wxPyBeginAllowThreads();
6500         result = (bool)((wxStaticLine const *)arg1)->IsVertical();
6501
6502         wxPyEndAllowThreads(__tstate);
6503         if (PyErr_Occurred()) SWIG_fail;
6504     }
6505     {
6506         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6507     }
6508     return resultobj;
6509     fail:
6510     return NULL;
6511 }
6512
6513
6514 static PyObject *_wrap_StaticLine_GetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
6515     PyObject *resultobj;
6516     int result;
6517     char *kwnames[] = {
6518         NULL
6519     };
6520
6521     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StaticLine_GetDefaultSize",kwnames)) goto fail;
6522     {
6523         PyThreadState* __tstate = wxPyBeginAllowThreads();
6524         result = (int)wxStaticLine::GetDefaultSize();
6525
6526         wxPyEndAllowThreads(__tstate);
6527         if (PyErr_Occurred()) SWIG_fail;
6528     }
6529     {
6530         resultobj = SWIG_From_int((int)(result));
6531     }
6532     return resultobj;
6533     fail:
6534     return NULL;
6535 }
6536
6537
6538 static PyObject *_wrap_StaticLine_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6539     PyObject *resultobj;
6540     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6541     wxVisualAttributes result;
6542     PyObject * obj0 = 0 ;
6543     char *kwnames[] = {
6544         (char *) "variant", NULL
6545     };
6546
6547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticLine_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6548     if (obj0) {
6549         {
6550             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6551             if (SWIG_arg_fail(1)) SWIG_fail;
6552         }
6553     }
6554     {
6555         if (!wxPyCheckForApp()) SWIG_fail;
6556         PyThreadState* __tstate = wxPyBeginAllowThreads();
6557         result = wxStaticLine::GetClassDefaultAttributes((wxWindowVariant )arg1);
6558
6559         wxPyEndAllowThreads(__tstate);
6560         if (PyErr_Occurred()) SWIG_fail;
6561     }
6562     {
6563         wxVisualAttributes * resultptr;
6564         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6565         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6566     }
6567     return resultobj;
6568     fail:
6569     return NULL;
6570 }
6571
6572
6573 static PyObject * StaticLine_swigregister(PyObject *, PyObject *args) {
6574     PyObject *obj;
6575     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6576     SWIG_TypeClientData(SWIGTYPE_p_wxStaticLine, obj);
6577     Py_INCREF(obj);
6578     return Py_BuildValue((char *)"");
6579 }
6580 static PyObject *_wrap_new_StaticText(PyObject *, PyObject *args, PyObject *kwargs) {
6581     PyObject *resultobj;
6582     wxWindow *arg1 = (wxWindow *) 0 ;
6583     int arg2 = (int) -1 ;
6584     wxString const &arg3_defvalue = wxPyEmptyString ;
6585     wxString *arg3 = (wxString *) &arg3_defvalue ;
6586     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6587     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6588     wxSize const &arg5_defvalue = wxDefaultSize ;
6589     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6590     long arg6 = (long) 0 ;
6591     wxString const &arg7_defvalue = wxPyStaticTextNameStr ;
6592     wxString *arg7 = (wxString *) &arg7_defvalue ;
6593     wxStaticText *result;
6594     bool temp3 = false ;
6595     wxPoint temp4 ;
6596     wxSize temp5 ;
6597     bool temp7 = false ;
6598     PyObject * obj0 = 0 ;
6599     PyObject * obj1 = 0 ;
6600     PyObject * obj2 = 0 ;
6601     PyObject * obj3 = 0 ;
6602     PyObject * obj4 = 0 ;
6603     PyObject * obj5 = 0 ;
6604     PyObject * obj6 = 0 ;
6605     char *kwnames[] = {
6606         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6607     };
6608
6609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6610     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6611     if (SWIG_arg_fail(1)) SWIG_fail;
6612     if (obj1) {
6613         {
6614             arg2 = (int)(SWIG_As_int(obj1));
6615             if (SWIG_arg_fail(2)) SWIG_fail;
6616         }
6617     }
6618     if (obj2) {
6619         {
6620             arg3 = wxString_in_helper(obj2);
6621             if (arg3 == NULL) SWIG_fail;
6622             temp3 = true;
6623         }
6624     }
6625     if (obj3) {
6626         {
6627             arg4 = &temp4;
6628             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6629         }
6630     }
6631     if (obj4) {
6632         {
6633             arg5 = &temp5;
6634             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6635         }
6636     }
6637     if (obj5) {
6638         {
6639             arg6 = (long)(SWIG_As_long(obj5));
6640             if (SWIG_arg_fail(6)) SWIG_fail;
6641         }
6642     }
6643     if (obj6) {
6644         {
6645             arg7 = wxString_in_helper(obj6);
6646             if (arg7 == NULL) SWIG_fail;
6647             temp7 = true;
6648         }
6649     }
6650     {
6651         if (!wxPyCheckForApp()) SWIG_fail;
6652         PyThreadState* __tstate = wxPyBeginAllowThreads();
6653         result = (wxStaticText *)new wxStaticText(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6654
6655         wxPyEndAllowThreads(__tstate);
6656         if (PyErr_Occurred()) SWIG_fail;
6657     }
6658     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticText, 1);
6659     {
6660         if (temp3)
6661         delete arg3;
6662     }
6663     {
6664         if (temp7)
6665         delete arg7;
6666     }
6667     return resultobj;
6668     fail:
6669     {
6670         if (temp3)
6671         delete arg3;
6672     }
6673     {
6674         if (temp7)
6675         delete arg7;
6676     }
6677     return NULL;
6678 }
6679
6680
6681 static PyObject *_wrap_new_PreStaticText(PyObject *, PyObject *args, PyObject *kwargs) {
6682     PyObject *resultobj;
6683     wxStaticText *result;
6684     char *kwnames[] = {
6685         NULL
6686     };
6687
6688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticText",kwnames)) goto fail;
6689     {
6690         if (!wxPyCheckForApp()) SWIG_fail;
6691         PyThreadState* __tstate = wxPyBeginAllowThreads();
6692         result = (wxStaticText *)new wxStaticText();
6693
6694         wxPyEndAllowThreads(__tstate);
6695         if (PyErr_Occurred()) SWIG_fail;
6696     }
6697     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticText, 1);
6698     return resultobj;
6699     fail:
6700     return NULL;
6701 }
6702
6703
6704 static PyObject *_wrap_StaticText_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6705     PyObject *resultobj;
6706     wxStaticText *arg1 = (wxStaticText *) 0 ;
6707     wxWindow *arg2 = (wxWindow *) 0 ;
6708     int arg3 = (int) -1 ;
6709     wxString const &arg4_defvalue = wxPyEmptyString ;
6710     wxString *arg4 = (wxString *) &arg4_defvalue ;
6711     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6712     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6713     wxSize const &arg6_defvalue = wxDefaultSize ;
6714     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6715     long arg7 = (long) 0 ;
6716     wxString const &arg8_defvalue = wxPyStaticTextNameStr ;
6717     wxString *arg8 = (wxString *) &arg8_defvalue ;
6718     bool result;
6719     bool temp4 = false ;
6720     wxPoint temp5 ;
6721     wxSize temp6 ;
6722     bool temp8 = false ;
6723     PyObject * obj0 = 0 ;
6724     PyObject * obj1 = 0 ;
6725     PyObject * obj2 = 0 ;
6726     PyObject * obj3 = 0 ;
6727     PyObject * obj4 = 0 ;
6728     PyObject * obj5 = 0 ;
6729     PyObject * obj6 = 0 ;
6730     PyObject * obj7 = 0 ;
6731     char *kwnames[] = {
6732         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6733     };
6734
6735     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticText_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6736     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticText, SWIG_POINTER_EXCEPTION | 0);
6737     if (SWIG_arg_fail(1)) SWIG_fail;
6738     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6739     if (SWIG_arg_fail(2)) SWIG_fail;
6740     if (obj2) {
6741         {
6742             arg3 = (int)(SWIG_As_int(obj2));
6743             if (SWIG_arg_fail(3)) SWIG_fail;
6744         }
6745     }
6746     if (obj3) {
6747         {
6748             arg4 = wxString_in_helper(obj3);
6749             if (arg4 == NULL) SWIG_fail;
6750             temp4 = true;
6751         }
6752     }
6753     if (obj4) {
6754         {
6755             arg5 = &temp5;
6756             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6757         }
6758     }
6759     if (obj5) {
6760         {
6761             arg6 = &temp6;
6762             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6763         }
6764     }
6765     if (obj6) {
6766         {
6767             arg7 = (long)(SWIG_As_long(obj6));
6768             if (SWIG_arg_fail(7)) SWIG_fail;
6769         }
6770     }
6771     if (obj7) {
6772         {
6773             arg8 = wxString_in_helper(obj7);
6774             if (arg8 == NULL) SWIG_fail;
6775             temp8 = true;
6776         }
6777     }
6778     {
6779         PyThreadState* __tstate = wxPyBeginAllowThreads();
6780         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6781
6782         wxPyEndAllowThreads(__tstate);
6783         if (PyErr_Occurred()) SWIG_fail;
6784     }
6785     {
6786         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6787     }
6788     {
6789         if (temp4)
6790         delete arg4;
6791     }
6792     {
6793         if (temp8)
6794         delete arg8;
6795     }
6796     return resultobj;
6797     fail:
6798     {
6799         if (temp4)
6800         delete arg4;
6801     }
6802     {
6803         if (temp8)
6804         delete arg8;
6805     }
6806     return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_StaticText_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6811     PyObject *resultobj;
6812     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6813     wxVisualAttributes result;
6814     PyObject * obj0 = 0 ;
6815     char *kwnames[] = {
6816         (char *) "variant", NULL
6817     };
6818
6819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticText_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6820     if (obj0) {
6821         {
6822             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6823             if (SWIG_arg_fail(1)) SWIG_fail;
6824         }
6825     }
6826     {
6827         if (!wxPyCheckForApp()) SWIG_fail;
6828         PyThreadState* __tstate = wxPyBeginAllowThreads();
6829         result = wxStaticText::GetClassDefaultAttributes((wxWindowVariant )arg1);
6830
6831         wxPyEndAllowThreads(__tstate);
6832         if (PyErr_Occurred()) SWIG_fail;
6833     }
6834     {
6835         wxVisualAttributes * resultptr;
6836         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6837         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6838     }
6839     return resultobj;
6840     fail:
6841     return NULL;
6842 }
6843
6844
6845 static PyObject * StaticText_swigregister(PyObject *, PyObject *args) {
6846     PyObject *obj;
6847     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6848     SWIG_TypeClientData(SWIGTYPE_p_wxStaticText, obj);
6849     Py_INCREF(obj);
6850     return Py_BuildValue((char *)"");
6851 }
6852 static PyObject *_wrap_new_StaticBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6853     PyObject *resultobj;
6854     wxWindow *arg1 = (wxWindow *) 0 ;
6855     int arg2 = (int) -1 ;
6856     wxBitmap const &arg3_defvalue = wxNullBitmap ;
6857     wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
6858     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6859     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6860     wxSize const &arg5_defvalue = wxDefaultSize ;
6861     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6862     long arg6 = (long) 0 ;
6863     wxString const &arg7_defvalue = wxPyStaticBitmapNameStr ;
6864     wxString *arg7 = (wxString *) &arg7_defvalue ;
6865     wxStaticBitmap *result;
6866     wxPoint temp4 ;
6867     wxSize temp5 ;
6868     bool temp7 = false ;
6869     PyObject * obj0 = 0 ;
6870     PyObject * obj1 = 0 ;
6871     PyObject * obj2 = 0 ;
6872     PyObject * obj3 = 0 ;
6873     PyObject * obj4 = 0 ;
6874     PyObject * obj5 = 0 ;
6875     PyObject * obj6 = 0 ;
6876     char *kwnames[] = {
6877         (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6878     };
6879
6880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6882     if (SWIG_arg_fail(1)) SWIG_fail;
6883     if (obj1) {
6884         {
6885             arg2 = (int)(SWIG_As_int(obj1));
6886             if (SWIG_arg_fail(2)) SWIG_fail;
6887         }
6888     }
6889     if (obj2) {
6890         {
6891             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6892             if (SWIG_arg_fail(3)) SWIG_fail;
6893             if (arg3 == NULL) {
6894                 SWIG_null_ref("wxBitmap");
6895             }
6896             if (SWIG_arg_fail(3)) SWIG_fail;
6897         }
6898     }
6899     if (obj3) {
6900         {
6901             arg4 = &temp4;
6902             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6903         }
6904     }
6905     if (obj4) {
6906         {
6907             arg5 = &temp5;
6908             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6909         }
6910     }
6911     if (obj5) {
6912         {
6913             arg6 = (long)(SWIG_As_long(obj5));
6914             if (SWIG_arg_fail(6)) SWIG_fail;
6915         }
6916     }
6917     if (obj6) {
6918         {
6919             arg7 = wxString_in_helper(obj6);
6920             if (arg7 == NULL) SWIG_fail;
6921             temp7 = true;
6922         }
6923     }
6924     {
6925         if (!wxPyCheckForApp()) SWIG_fail;
6926         PyThreadState* __tstate = wxPyBeginAllowThreads();
6927         result = (wxStaticBitmap *)new wxStaticBitmap(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6928
6929         wxPyEndAllowThreads(__tstate);
6930         if (PyErr_Occurred()) SWIG_fail;
6931     }
6932     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBitmap, 1);
6933     {
6934         if (temp7)
6935         delete arg7;
6936     }
6937     return resultobj;
6938     fail:
6939     {
6940         if (temp7)
6941         delete arg7;
6942     }
6943     return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_new_PreStaticBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6948     PyObject *resultobj;
6949     wxStaticBitmap *result;
6950     char *kwnames[] = {
6951         NULL
6952     };
6953
6954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStaticBitmap",kwnames)) goto fail;
6955     {
6956         if (!wxPyCheckForApp()) SWIG_fail;
6957         PyThreadState* __tstate = wxPyBeginAllowThreads();
6958         result = (wxStaticBitmap *)new wxStaticBitmap();
6959
6960         wxPyEndAllowThreads(__tstate);
6961         if (PyErr_Occurred()) SWIG_fail;
6962     }
6963     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBitmap, 1);
6964     return resultobj;
6965     fail:
6966     return NULL;
6967 }
6968
6969
6970 static PyObject *_wrap_StaticBitmap_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6971     PyObject *resultobj;
6972     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
6973     wxWindow *arg2 = (wxWindow *) 0 ;
6974     int arg3 = (int) -1 ;
6975     wxBitmap const &arg4_defvalue = wxNullBitmap ;
6976     wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
6977     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6978     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6979     wxSize const &arg6_defvalue = wxDefaultSize ;
6980     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6981     long arg7 = (long) 0 ;
6982     wxString const &arg8_defvalue = wxPyStaticBitmapNameStr ;
6983     wxString *arg8 = (wxString *) &arg8_defvalue ;
6984     bool result;
6985     wxPoint temp5 ;
6986     wxSize temp6 ;
6987     bool temp8 = false ;
6988     PyObject * obj0 = 0 ;
6989     PyObject * obj1 = 0 ;
6990     PyObject * obj2 = 0 ;
6991     PyObject * obj3 = 0 ;
6992     PyObject * obj4 = 0 ;
6993     PyObject * obj5 = 0 ;
6994     PyObject * obj6 = 0 ;
6995     PyObject * obj7 = 0 ;
6996     char *kwnames[] = {
6997         (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6998     };
6999
7000     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBitmap_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
7001     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7002     if (SWIG_arg_fail(1)) SWIG_fail;
7003     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7004     if (SWIG_arg_fail(2)) SWIG_fail;
7005     if (obj2) {
7006         {
7007             arg3 = (int)(SWIG_As_int(obj2));
7008             if (SWIG_arg_fail(3)) SWIG_fail;
7009         }
7010     }
7011     if (obj3) {
7012         {
7013             SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7014             if (SWIG_arg_fail(4)) SWIG_fail;
7015             if (arg4 == NULL) {
7016                 SWIG_null_ref("wxBitmap");
7017             }
7018             if (SWIG_arg_fail(4)) SWIG_fail;
7019         }
7020     }
7021     if (obj4) {
7022         {
7023             arg5 = &temp5;
7024             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
7025         }
7026     }
7027     if (obj5) {
7028         {
7029             arg6 = &temp6;
7030             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
7031         }
7032     }
7033     if (obj6) {
7034         {
7035             arg7 = (long)(SWIG_As_long(obj6));
7036             if (SWIG_arg_fail(7)) SWIG_fail;
7037         }
7038     }
7039     if (obj7) {
7040         {
7041             arg8 = wxString_in_helper(obj7);
7042             if (arg8 == NULL) SWIG_fail;
7043             temp8 = true;
7044         }
7045     }
7046     {
7047         PyThreadState* __tstate = wxPyBeginAllowThreads();
7048         result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
7049
7050         wxPyEndAllowThreads(__tstate);
7051         if (PyErr_Occurred()) SWIG_fail;
7052     }
7053     {
7054         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7055     }
7056     {
7057         if (temp8)
7058         delete arg8;
7059     }
7060     return resultobj;
7061     fail:
7062     {
7063         if (temp8)
7064         delete arg8;
7065     }
7066     return NULL;
7067 }
7068
7069
7070 static PyObject *_wrap_StaticBitmap_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7071     PyObject *resultobj;
7072     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7073     wxBitmap result;
7074     PyObject * obj0 = 0 ;
7075     char *kwnames[] = {
7076         (char *) "self", NULL
7077     };
7078
7079     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBitmap_GetBitmap",kwnames,&obj0)) goto fail;
7080     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7081     if (SWIG_arg_fail(1)) SWIG_fail;
7082     {
7083         PyThreadState* __tstate = wxPyBeginAllowThreads();
7084         result = (arg1)->GetBitmap();
7085
7086         wxPyEndAllowThreads(__tstate);
7087         if (PyErr_Occurred()) SWIG_fail;
7088     }
7089     {
7090         wxBitmap * resultptr;
7091         resultptr = new wxBitmap((wxBitmap &)(result));
7092         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7093     }
7094     return resultobj;
7095     fail:
7096     return NULL;
7097 }
7098
7099
7100 static PyObject *_wrap_StaticBitmap_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7101     PyObject *resultobj;
7102     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7103     wxBitmap *arg2 = 0 ;
7104     PyObject * obj0 = 0 ;
7105     PyObject * obj1 = 0 ;
7106     char *kwnames[] = {
7107         (char *) "self",(char *) "bitmap", NULL
7108     };
7109
7110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
7111     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7112     if (SWIG_arg_fail(1)) SWIG_fail;
7113     {
7114         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7115         if (SWIG_arg_fail(2)) SWIG_fail;
7116         if (arg2 == NULL) {
7117             SWIG_null_ref("wxBitmap");
7118         }
7119         if (SWIG_arg_fail(2)) SWIG_fail;
7120     }
7121     {
7122         PyThreadState* __tstate = wxPyBeginAllowThreads();
7123         (arg1)->SetBitmap((wxBitmap const &)*arg2);
7124
7125         wxPyEndAllowThreads(__tstate);
7126         if (PyErr_Occurred()) SWIG_fail;
7127     }
7128     Py_INCREF(Py_None); resultobj = Py_None;
7129     return resultobj;
7130     fail:
7131     return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_StaticBitmap_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
7136     PyObject *resultobj;
7137     wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
7138     wxIcon *arg2 = 0 ;
7139     PyObject * obj0 = 0 ;
7140     PyObject * obj1 = 0 ;
7141     char *kwnames[] = {
7142         (char *) "self",(char *) "icon", NULL
7143     };
7144
7145     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetIcon",kwnames,&obj0,&obj1)) goto fail;
7146     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_EXCEPTION | 0);
7147     if (SWIG_arg_fail(1)) SWIG_fail;
7148     {
7149         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
7150         if (SWIG_arg_fail(2)) SWIG_fail;
7151         if (arg2 == NULL) {
7152             SWIG_null_ref("wxIcon");
7153         }
7154         if (SWIG_arg_fail(2)) SWIG_fail;
7155     }
7156     {
7157         PyThreadState* __tstate = wxPyBeginAllowThreads();
7158         (arg1)->SetIcon((wxIcon const &)*arg2);
7159
7160         wxPyEndAllowThreads(__tstate);
7161         if (PyErr_Occurred()) SWIG_fail;
7162     }
7163     Py_INCREF(Py_None); resultobj = Py_None;
7164     return resultobj;
7165     fail:
7166     return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_StaticBitmap_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7171     PyObject *resultobj;
7172     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7173     wxVisualAttributes result;
7174     PyObject * obj0 = 0 ;
7175     char *kwnames[] = {
7176         (char *) "variant", NULL
7177     };
7178
7179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBitmap_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7180     if (obj0) {
7181         {
7182             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7183             if (SWIG_arg_fail(1)) SWIG_fail;
7184         }
7185     }
7186     {
7187         if (!wxPyCheckForApp()) SWIG_fail;
7188         PyThreadState* __tstate = wxPyBeginAllowThreads();
7189         result = wxStaticBitmap::GetClassDefaultAttributes((wxWindowVariant )arg1);
7190
7191         wxPyEndAllowThreads(__tstate);
7192         if (PyErr_Occurred()) SWIG_fail;
7193     }
7194     {
7195         wxVisualAttributes * resultptr;
7196         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7197         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7198     }
7199     return resultobj;
7200     fail:
7201     return NULL;
7202 }
7203
7204
7205 static PyObject * StaticBitmap_swigregister(PyObject *, PyObject *args) {
7206     PyObject *obj;
7207     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7208     SWIG_TypeClientData(SWIGTYPE_p_wxStaticBitmap, obj);
7209     Py_INCREF(obj);
7210     return Py_BuildValue((char *)"");
7211 }
7212 static int _wrap_ListBoxNameStr_set(PyObject *) {
7213     PyErr_SetString(PyExc_TypeError,"Variable ListBoxNameStr is read-only.");
7214     return 1;
7215 }
7216
7217
7218 static PyObject *_wrap_ListBoxNameStr_get(void) {
7219     PyObject *pyobj;
7220
7221     {
7222 #if wxUSE_UNICODE
7223         pyobj = PyUnicode_FromWideChar((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
7224 #else
7225         pyobj = PyString_FromStringAndSize((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
7226 #endif
7227     }
7228     return pyobj;
7229 }
7230
7231
7232 static PyObject *_wrap_new_ListBox(PyObject *, PyObject *args, PyObject *kwargs) {
7233     PyObject *resultobj;
7234     wxWindow *arg1 = (wxWindow *) 0 ;
7235     int arg2 = (int) -1 ;
7236     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7237     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7238     wxSize const &arg4_defvalue = wxDefaultSize ;
7239     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7240     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
7241     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
7242     long arg6 = (long) 0 ;
7243     wxValidator const &arg7_defvalue = wxDefaultValidator ;
7244     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
7245     wxString const &arg8_defvalue = wxPyListBoxNameStr ;
7246     wxString *arg8 = (wxString *) &arg8_defvalue ;
7247     wxListBox *result;
7248     wxPoint temp3 ;
7249     wxSize temp4 ;
7250     bool temp5 = false ;
7251     bool temp8 = false ;
7252     PyObject * obj0 = 0 ;
7253     PyObject * obj1 = 0 ;
7254     PyObject * obj2 = 0 ;
7255     PyObject * obj3 = 0 ;
7256     PyObject * obj4 = 0 ;
7257     PyObject * obj5 = 0 ;
7258     PyObject * obj6 = 0 ;
7259     PyObject * obj7 = 0 ;
7260     char *kwnames[] = {
7261         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
7262     };
7263
7264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
7265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7266     if (SWIG_arg_fail(1)) SWIG_fail;
7267     if (obj1) {
7268         {
7269             arg2 = (int)(SWIG_As_int(obj1));
7270             if (SWIG_arg_fail(2)) SWIG_fail;
7271         }
7272     }
7273     if (obj2) {
7274         {
7275             arg3 = &temp3;
7276             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7277         }
7278     }
7279     if (obj3) {
7280         {
7281             arg4 = &temp4;
7282             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7283         }
7284     }
7285     if (obj4) {
7286         {
7287             if (! PySequence_Check(obj4)) {
7288                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7289                 SWIG_fail;
7290             }
7291             arg5 = new wxArrayString;
7292             temp5 = true;
7293             int i, len=PySequence_Length(obj4);
7294             for (i=0; i<len; i++) {
7295                 PyObject* item = PySequence_GetItem(obj4, i);
7296 #if wxUSE_UNICODE
7297                 PyObject* str  = PyObject_Unicode(item);
7298 #else
7299                 PyObject* str  = PyObject_Str(item);
7300 #endif
7301                 if (PyErr_Occurred())  SWIG_fail;
7302                 arg5->Add(Py2wxString(str));
7303                 Py_DECREF(item);
7304                 Py_DECREF(str);
7305             }
7306         }
7307     }
7308     if (obj5) {
7309         {
7310             arg6 = (long)(SWIG_As_long(obj5));
7311             if (SWIG_arg_fail(6)) SWIG_fail;
7312         }
7313     }
7314     if (obj6) {
7315         {
7316             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
7317             if (SWIG_arg_fail(7)) SWIG_fail;
7318             if (arg7 == NULL) {
7319                 SWIG_null_ref("wxValidator");
7320             }
7321             if (SWIG_arg_fail(7)) SWIG_fail;
7322         }
7323     }
7324     if (obj7) {
7325         {
7326             arg8 = wxString_in_helper(obj7);
7327             if (arg8 == NULL) SWIG_fail;
7328             temp8 = true;
7329         }
7330     }
7331     {
7332         if (!wxPyCheckForApp()) SWIG_fail;
7333         PyThreadState* __tstate = wxPyBeginAllowThreads();
7334         result = (wxListBox *)new wxListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
7335
7336         wxPyEndAllowThreads(__tstate);
7337         if (PyErr_Occurred()) SWIG_fail;
7338     }
7339     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListBox, 1);
7340     {
7341         if (temp5) delete arg5;
7342     }
7343     {
7344         if (temp8)
7345         delete arg8;
7346     }
7347     return resultobj;
7348     fail:
7349     {
7350         if (temp5) delete arg5;
7351     }
7352     {
7353         if (temp8)
7354         delete arg8;
7355     }
7356     return NULL;
7357 }
7358
7359
7360 static PyObject *_wrap_new_PreListBox(PyObject *, PyObject *args, PyObject *kwargs) {
7361     PyObject *resultobj;
7362     wxListBox *result;
7363     char *kwnames[] = {
7364         NULL
7365     };
7366
7367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListBox",kwnames)) goto fail;
7368     {
7369         if (!wxPyCheckForApp()) SWIG_fail;
7370         PyThreadState* __tstate = wxPyBeginAllowThreads();
7371         result = (wxListBox *)new wxListBox();
7372
7373         wxPyEndAllowThreads(__tstate);
7374         if (PyErr_Occurred()) SWIG_fail;
7375     }
7376     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListBox, 1);
7377     return resultobj;
7378     fail:
7379     return NULL;
7380 }
7381
7382
7383 static PyObject *_wrap_ListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7384     PyObject *resultobj;
7385     wxListBox *arg1 = (wxListBox *) 0 ;
7386     wxWindow *arg2 = (wxWindow *) 0 ;
7387     int arg3 = (int) -1 ;
7388     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7389     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7390     wxSize const &arg5_defvalue = wxDefaultSize ;
7391     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7392     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
7393     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
7394     long arg7 = (long) 0 ;
7395     wxValidator const &arg8_defvalue = wxDefaultValidator ;
7396     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
7397     wxString const &arg9_defvalue = wxPyListBoxNameStr ;
7398     wxString *arg9 = (wxString *) &arg9_defvalue ;
7399     bool result;
7400     wxPoint temp4 ;
7401     wxSize temp5 ;
7402     bool temp6 = false ;
7403     bool temp9 = false ;
7404     PyObject * obj0 = 0 ;
7405     PyObject * obj1 = 0 ;
7406     PyObject * obj2 = 0 ;
7407     PyObject * obj3 = 0 ;
7408     PyObject * obj4 = 0 ;
7409     PyObject * obj5 = 0 ;
7410     PyObject * obj6 = 0 ;
7411     PyObject * obj7 = 0 ;
7412     PyObject * obj8 = 0 ;
7413     char *kwnames[] = {
7414         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
7415     };
7416
7417     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
7418     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7419     if (SWIG_arg_fail(1)) SWIG_fail;
7420     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7421     if (SWIG_arg_fail(2)) SWIG_fail;
7422     if (obj2) {
7423         {
7424             arg3 = (int)(SWIG_As_int(obj2));
7425             if (SWIG_arg_fail(3)) SWIG_fail;
7426         }
7427     }
7428     if (obj3) {
7429         {
7430             arg4 = &temp4;
7431             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7432         }
7433     }
7434     if (obj4) {
7435         {
7436             arg5 = &temp5;
7437             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7438         }
7439     }
7440     if (obj5) {
7441         {
7442             if (! PySequence_Check(obj5)) {
7443                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7444                 SWIG_fail;
7445             }
7446             arg6 = new wxArrayString;
7447             temp6 = true;
7448             int i, len=PySequence_Length(obj5);
7449             for (i=0; i<len; i++) {
7450                 PyObject* item = PySequence_GetItem(obj5, i);
7451 #if wxUSE_UNICODE
7452                 PyObject* str  = PyObject_Unicode(item);
7453 #else
7454                 PyObject* str  = PyObject_Str(item);
7455 #endif
7456                 if (PyErr_Occurred())  SWIG_fail;
7457                 arg6->Add(Py2wxString(str));
7458                 Py_DECREF(item);
7459                 Py_DECREF(str);
7460             }
7461         }
7462     }
7463     if (obj6) {
7464         {
7465             arg7 = (long)(SWIG_As_long(obj6));
7466             if (SWIG_arg_fail(7)) SWIG_fail;
7467         }
7468     }
7469     if (obj7) {
7470         {
7471             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
7472             if (SWIG_arg_fail(8)) SWIG_fail;
7473             if (arg8 == NULL) {
7474                 SWIG_null_ref("wxValidator");
7475             }
7476             if (SWIG_arg_fail(8)) SWIG_fail;
7477         }
7478     }
7479     if (obj8) {
7480         {
7481             arg9 = wxString_in_helper(obj8);
7482             if (arg9 == NULL) SWIG_fail;
7483             temp9 = true;
7484         }
7485     }
7486     {
7487         PyThreadState* __tstate = wxPyBeginAllowThreads();
7488         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
7489
7490         wxPyEndAllowThreads(__tstate);
7491         if (PyErr_Occurred()) SWIG_fail;
7492     }
7493     {
7494         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495     }
7496     {
7497         if (temp6) delete arg6;
7498     }
7499     {
7500         if (temp9)
7501         delete arg9;
7502     }
7503     return resultobj;
7504     fail:
7505     {
7506         if (temp6) delete arg6;
7507     }
7508     {
7509         if (temp9)
7510         delete arg9;
7511     }
7512     return NULL;
7513 }
7514
7515
7516 static PyObject *_wrap_ListBox_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
7517     PyObject *resultobj;
7518     wxListBox *arg1 = (wxListBox *) 0 ;
7519     wxString *arg2 = 0 ;
7520     int arg3 ;
7521     PyObject *arg4 = (PyObject *) NULL ;
7522     bool temp2 = false ;
7523     PyObject * obj0 = 0 ;
7524     PyObject * obj1 = 0 ;
7525     PyObject * obj2 = 0 ;
7526     PyObject * obj3 = 0 ;
7527     char *kwnames[] = {
7528         (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
7529     };
7530
7531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListBox_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7533     if (SWIG_arg_fail(1)) SWIG_fail;
7534     {
7535         arg2 = wxString_in_helper(obj1);
7536         if (arg2 == NULL) SWIG_fail;
7537         temp2 = true;
7538     }
7539     {
7540         arg3 = (int)(SWIG_As_int(obj2));
7541         if (SWIG_arg_fail(3)) SWIG_fail;
7542     }
7543     if (obj3) {
7544         arg4 = obj3;
7545     }
7546     {
7547         PyThreadState* __tstate = wxPyBeginAllowThreads();
7548         wxListBox_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
7549
7550         wxPyEndAllowThreads(__tstate);
7551         if (PyErr_Occurred()) SWIG_fail;
7552     }
7553     Py_INCREF(Py_None); resultobj = Py_None;
7554     {
7555         if (temp2)
7556         delete arg2;
7557     }
7558     return resultobj;
7559     fail:
7560     {
7561         if (temp2)
7562         delete arg2;
7563     }
7564     return NULL;
7565 }
7566
7567
7568 static PyObject *_wrap_ListBox_InsertItems(PyObject *, PyObject *args, PyObject *kwargs) {
7569     PyObject *resultobj;
7570     wxListBox *arg1 = (wxListBox *) 0 ;
7571     wxArrayString *arg2 = 0 ;
7572     int arg3 ;
7573     bool temp2 = false ;
7574     PyObject * obj0 = 0 ;
7575     PyObject * obj1 = 0 ;
7576     PyObject * obj2 = 0 ;
7577     char *kwnames[] = {
7578         (char *) "self",(char *) "items",(char *) "pos", NULL
7579     };
7580
7581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_InsertItems",kwnames,&obj0,&obj1,&obj2)) goto fail;
7582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7583     if (SWIG_arg_fail(1)) SWIG_fail;
7584     {
7585         if (! PySequence_Check(obj1)) {
7586             PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7587             SWIG_fail;
7588         }
7589         arg2 = new wxArrayString;
7590         temp2 = true;
7591         int i, len=PySequence_Length(obj1);
7592         for (i=0; i<len; i++) {
7593             PyObject* item = PySequence_GetItem(obj1, i);
7594 #if wxUSE_UNICODE
7595             PyObject* str  = PyObject_Unicode(item);
7596 #else
7597             PyObject* str  = PyObject_Str(item);
7598 #endif
7599             if (PyErr_Occurred())  SWIG_fail;
7600             arg2->Add(Py2wxString(str));
7601             Py_DECREF(item);
7602             Py_DECREF(str);
7603         }
7604     }
7605     {
7606         arg3 = (int)(SWIG_As_int(obj2));
7607         if (SWIG_arg_fail(3)) SWIG_fail;
7608     }
7609     {
7610         PyThreadState* __tstate = wxPyBeginAllowThreads();
7611         (arg1)->InsertItems((wxArrayString const &)*arg2,arg3);
7612
7613         wxPyEndAllowThreads(__tstate);
7614         if (PyErr_Occurred()) SWIG_fail;
7615     }
7616     Py_INCREF(Py_None); resultobj = Py_None;
7617     {
7618         if (temp2) delete arg2;
7619     }
7620     return resultobj;
7621     fail:
7622     {
7623         if (temp2) delete arg2;
7624     }
7625     return NULL;
7626 }
7627
7628
7629 static PyObject *_wrap_ListBox_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7630     PyObject *resultobj;
7631     wxListBox *arg1 = (wxListBox *) 0 ;
7632     wxArrayString *arg2 = 0 ;
7633     bool temp2 = false ;
7634     PyObject * obj0 = 0 ;
7635     PyObject * obj1 = 0 ;
7636     char *kwnames[] = {
7637         (char *) "self",(char *) "items", NULL
7638     };
7639
7640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Set",kwnames,&obj0,&obj1)) goto fail;
7641     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7642     if (SWIG_arg_fail(1)) SWIG_fail;
7643     {
7644         if (! PySequence_Check(obj1)) {
7645             PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7646             SWIG_fail;
7647         }
7648         arg2 = new wxArrayString;
7649         temp2 = true;
7650         int i, len=PySequence_Length(obj1);
7651         for (i=0; i<len; i++) {
7652             PyObject* item = PySequence_GetItem(obj1, i);
7653 #if wxUSE_UNICODE
7654             PyObject* str  = PyObject_Unicode(item);
7655 #else
7656             PyObject* str  = PyObject_Str(item);
7657 #endif
7658             if (PyErr_Occurred())  SWIG_fail;
7659             arg2->Add(Py2wxString(str));
7660             Py_DECREF(item);
7661             Py_DECREF(str);
7662         }
7663     }
7664     {
7665         PyThreadState* __tstate = wxPyBeginAllowThreads();
7666         (arg1)->Set((wxArrayString const &)*arg2);
7667
7668         wxPyEndAllowThreads(__tstate);
7669         if (PyErr_Occurred()) SWIG_fail;
7670     }
7671     Py_INCREF(Py_None); resultobj = Py_None;
7672     {
7673         if (temp2) delete arg2;
7674     }
7675     return resultobj;
7676     fail:
7677     {
7678         if (temp2) delete arg2;
7679     }
7680     return NULL;
7681 }
7682
7683
7684 static PyObject *_wrap_ListBox_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
7685     PyObject *resultobj;
7686     wxListBox *arg1 = (wxListBox *) 0 ;
7687     int arg2 ;
7688     bool result;
7689     PyObject * obj0 = 0 ;
7690     PyObject * obj1 = 0 ;
7691     char *kwnames[] = {
7692         (char *) "self",(char *) "n", NULL
7693     };
7694
7695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
7696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7697     if (SWIG_arg_fail(1)) SWIG_fail;
7698     {
7699         arg2 = (int)(SWIG_As_int(obj1));
7700         if (SWIG_arg_fail(2)) SWIG_fail;
7701     }
7702     {
7703         PyThreadState* __tstate = wxPyBeginAllowThreads();
7704         result = (bool)((wxListBox const *)arg1)->IsSelected(arg2);
7705
7706         wxPyEndAllowThreads(__tstate);
7707         if (PyErr_Occurred()) SWIG_fail;
7708     }
7709     {
7710         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711     }
7712     return resultobj;
7713     fail:
7714     return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_ListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
7719     PyObject *resultobj;
7720     wxListBox *arg1 = (wxListBox *) 0 ;
7721     int arg2 ;
7722     bool arg3 = (bool) true ;
7723     PyObject * obj0 = 0 ;
7724     PyObject * obj1 = 0 ;
7725     PyObject * obj2 = 0 ;
7726     char *kwnames[] = {
7727         (char *) "self",(char *) "n",(char *) "select", NULL
7728     };
7729
7730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
7731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7732     if (SWIG_arg_fail(1)) SWIG_fail;
7733     {
7734         arg2 = (int)(SWIG_As_int(obj1));
7735         if (SWIG_arg_fail(2)) SWIG_fail;
7736     }
7737     if (obj2) {
7738         {
7739             arg3 = (bool)(SWIG_As_bool(obj2));
7740             if (SWIG_arg_fail(3)) SWIG_fail;
7741         }
7742     }
7743     {
7744         PyThreadState* __tstate = wxPyBeginAllowThreads();
7745         (arg1)->SetSelection(arg2,arg3);
7746
7747         wxPyEndAllowThreads(__tstate);
7748         if (PyErr_Occurred()) SWIG_fail;
7749     }
7750     Py_INCREF(Py_None); resultobj = Py_None;
7751     return resultobj;
7752     fail:
7753     return NULL;
7754 }
7755
7756
7757 static PyObject *_wrap_ListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
7758     PyObject *resultobj;
7759     wxListBox *arg1 = (wxListBox *) 0 ;
7760     int arg2 ;
7761     PyObject * obj0 = 0 ;
7762     PyObject * obj1 = 0 ;
7763     char *kwnames[] = {
7764         (char *) "self",(char *) "n", NULL
7765     };
7766
7767     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Select",kwnames,&obj0,&obj1)) goto fail;
7768     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7769     if (SWIG_arg_fail(1)) SWIG_fail;
7770     {
7771         arg2 = (int)(SWIG_As_int(obj1));
7772         if (SWIG_arg_fail(2)) SWIG_fail;
7773     }
7774     {
7775         PyThreadState* __tstate = wxPyBeginAllowThreads();
7776         (arg1)->Select(arg2);
7777
7778         wxPyEndAllowThreads(__tstate);
7779         if (PyErr_Occurred()) SWIG_fail;
7780     }
7781     Py_INCREF(Py_None); resultobj = Py_None;
7782     return resultobj;
7783     fail:
7784     return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_ListBox_Deselect(PyObject *, PyObject *args, PyObject *kwargs) {
7789     PyObject *resultobj;
7790     wxListBox *arg1 = (wxListBox *) 0 ;
7791     int arg2 ;
7792     PyObject * obj0 = 0 ;
7793     PyObject * obj1 = 0 ;
7794     char *kwnames[] = {
7795         (char *) "self",(char *) "n", NULL
7796     };
7797
7798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Deselect",kwnames,&obj0,&obj1)) goto fail;
7799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7800     if (SWIG_arg_fail(1)) SWIG_fail;
7801     {
7802         arg2 = (int)(SWIG_As_int(obj1));
7803         if (SWIG_arg_fail(2)) SWIG_fail;
7804     }
7805     {
7806         PyThreadState* __tstate = wxPyBeginAllowThreads();
7807         (arg1)->Deselect(arg2);
7808
7809         wxPyEndAllowThreads(__tstate);
7810         if (PyErr_Occurred()) SWIG_fail;
7811     }
7812     Py_INCREF(Py_None); resultobj = Py_None;
7813     return resultobj;
7814     fail:
7815     return NULL;
7816 }
7817
7818
7819 static PyObject *_wrap_ListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
7820     PyObject *resultobj;
7821     wxListBox *arg1 = (wxListBox *) 0 ;
7822     int arg2 = (int) -1 ;
7823     PyObject * obj0 = 0 ;
7824     PyObject * obj1 = 0 ;
7825     char *kwnames[] = {
7826         (char *) "self",(char *) "itemToLeaveSelected", NULL
7827     };
7828
7829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListBox_DeselectAll",kwnames,&obj0,&obj1)) goto fail;
7830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7831     if (SWIG_arg_fail(1)) SWIG_fail;
7832     if (obj1) {
7833         {
7834             arg2 = (int)(SWIG_As_int(obj1));
7835             if (SWIG_arg_fail(2)) SWIG_fail;
7836         }
7837     }
7838     {
7839         PyThreadState* __tstate = wxPyBeginAllowThreads();
7840         (arg1)->DeselectAll(arg2);
7841
7842         wxPyEndAllowThreads(__tstate);
7843         if (PyErr_Occurred()) SWIG_fail;
7844     }
7845     Py_INCREF(Py_None); resultobj = Py_None;
7846     return resultobj;
7847     fail:
7848     return NULL;
7849 }
7850
7851
7852 static PyObject *_wrap_ListBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
7853     PyObject *resultobj;
7854     wxListBox *arg1 = (wxListBox *) 0 ;
7855     wxString *arg2 = 0 ;
7856     bool arg3 = (bool) true ;
7857     bool result;
7858     bool temp2 = false ;
7859     PyObject * obj0 = 0 ;
7860     PyObject * obj1 = 0 ;
7861     PyObject * obj2 = 0 ;
7862     char *kwnames[] = {
7863         (char *) "self",(char *) "s",(char *) "select", NULL
7864     };
7865
7866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetStringSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
7867     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7868     if (SWIG_arg_fail(1)) SWIG_fail;
7869     {
7870         arg2 = wxString_in_helper(obj1);
7871         if (arg2 == NULL) SWIG_fail;
7872         temp2 = true;
7873     }
7874     if (obj2) {
7875         {
7876             arg3 = (bool)(SWIG_As_bool(obj2));
7877             if (SWIG_arg_fail(3)) SWIG_fail;
7878         }
7879     }
7880     {
7881         PyThreadState* __tstate = wxPyBeginAllowThreads();
7882         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2,arg3);
7883
7884         wxPyEndAllowThreads(__tstate);
7885         if (PyErr_Occurred()) SWIG_fail;
7886     }
7887     {
7888         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7889     }
7890     {
7891         if (temp2)
7892         delete arg2;
7893     }
7894     return resultobj;
7895     fail:
7896     {
7897         if (temp2)
7898         delete arg2;
7899     }
7900     return NULL;
7901 }
7902
7903
7904 static PyObject *_wrap_ListBox_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
7905     PyObject *resultobj;
7906     wxListBox *arg1 = (wxListBox *) 0 ;
7907     PyObject *result;
7908     PyObject * obj0 = 0 ;
7909     char *kwnames[] = {
7910         (char *) "self", NULL
7911     };
7912
7913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListBox_GetSelections",kwnames,&obj0)) goto fail;
7914     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7915     if (SWIG_arg_fail(1)) SWIG_fail;
7916     {
7917         PyThreadState* __tstate = wxPyBeginAllowThreads();
7918         result = (PyObject *)wxListBox_GetSelections(arg1);
7919
7920         wxPyEndAllowThreads(__tstate);
7921         if (PyErr_Occurred()) SWIG_fail;
7922     }
7923     resultobj = result;
7924     return resultobj;
7925     fail:
7926     return NULL;
7927 }
7928
7929
7930 static PyObject *_wrap_ListBox_SetFirstItem(PyObject *, PyObject *args, PyObject *kwargs) {
7931     PyObject *resultobj;
7932     wxListBox *arg1 = (wxListBox *) 0 ;
7933     int arg2 ;
7934     PyObject * obj0 = 0 ;
7935     PyObject * obj1 = 0 ;
7936     char *kwnames[] = {
7937         (char *) "self",(char *) "n", NULL
7938     };
7939
7940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItem",kwnames,&obj0,&obj1)) goto fail;
7941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7942     if (SWIG_arg_fail(1)) SWIG_fail;
7943     {
7944         arg2 = (int)(SWIG_As_int(obj1));
7945         if (SWIG_arg_fail(2)) SWIG_fail;
7946     }
7947     {
7948         PyThreadState* __tstate = wxPyBeginAllowThreads();
7949         (arg1)->SetFirstItem(arg2);
7950
7951         wxPyEndAllowThreads(__tstate);
7952         if (PyErr_Occurred()) SWIG_fail;
7953     }
7954     Py_INCREF(Py_None); resultobj = Py_None;
7955     return resultobj;
7956     fail:
7957     return NULL;
7958 }
7959
7960
7961 static PyObject *_wrap_ListBox_SetFirstItemStr(PyObject *, PyObject *args, PyObject *kwargs) {
7962     PyObject *resultobj;
7963     wxListBox *arg1 = (wxListBox *) 0 ;
7964     wxString *arg2 = 0 ;
7965     bool temp2 = false ;
7966     PyObject * obj0 = 0 ;
7967     PyObject * obj1 = 0 ;
7968     char *kwnames[] = {
7969         (char *) "self",(char *) "s", NULL
7970     };
7971
7972     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItemStr",kwnames,&obj0,&obj1)) goto fail;
7973     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
7974     if (SWIG_arg_fail(1)) SWIG_fail;
7975     {
7976         arg2 = wxString_in_helper(obj1);
7977         if (arg2 == NULL) SWIG_fail;
7978         temp2 = true;
7979     }
7980     {
7981         PyThreadState* __tstate = wxPyBeginAllowThreads();
7982         (arg1)->SetFirstItem((wxString const &)*arg2);
7983
7984         wxPyEndAllowThreads(__tstate);
7985         if (PyErr_Occurred()) SWIG_fail;
7986     }
7987     Py_INCREF(Py_None); resultobj = Py_None;
7988     {
7989         if (temp2)
7990         delete arg2;
7991     }
7992     return resultobj;
7993     fail:
7994     {
7995         if (temp2)
7996         delete arg2;
7997     }
7998     return NULL;
7999 }
8000
8001
8002 static PyObject *_wrap_ListBox_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8003     PyObject *resultobj;
8004     wxListBox *arg1 = (wxListBox *) 0 ;
8005     int arg2 ;
8006     PyObject * obj0 = 0 ;
8007     PyObject * obj1 = 0 ;
8008     char *kwnames[] = {
8009         (char *) "self",(char *) "n", NULL
8010     };
8011
8012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
8013     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8014     if (SWIG_arg_fail(1)) SWIG_fail;
8015     {
8016         arg2 = (int)(SWIG_As_int(obj1));
8017         if (SWIG_arg_fail(2)) SWIG_fail;
8018     }
8019     {
8020         PyThreadState* __tstate = wxPyBeginAllowThreads();
8021         (arg1)->EnsureVisible(arg2);
8022
8023         wxPyEndAllowThreads(__tstate);
8024         if (PyErr_Occurred()) SWIG_fail;
8025     }
8026     Py_INCREF(Py_None); resultobj = Py_None;
8027     return resultobj;
8028     fail:
8029     return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_ListBox_AppendAndEnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8034     PyObject *resultobj;
8035     wxListBox *arg1 = (wxListBox *) 0 ;
8036     wxString *arg2 = 0 ;
8037     bool temp2 = false ;
8038     PyObject * obj0 = 0 ;
8039     PyObject * obj1 = 0 ;
8040     char *kwnames[] = {
8041         (char *) "self",(char *) "s", NULL
8042     };
8043
8044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_AppendAndEnsureVisible",kwnames,&obj0,&obj1)) goto fail;
8045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8046     if (SWIG_arg_fail(1)) SWIG_fail;
8047     {
8048         arg2 = wxString_in_helper(obj1);
8049         if (arg2 == NULL) SWIG_fail;
8050         temp2 = true;
8051     }
8052     {
8053         PyThreadState* __tstate = wxPyBeginAllowThreads();
8054         (arg1)->AppendAndEnsureVisible((wxString const &)*arg2);
8055
8056         wxPyEndAllowThreads(__tstate);
8057         if (PyErr_Occurred()) SWIG_fail;
8058     }
8059     Py_INCREF(Py_None); resultobj = Py_None;
8060     {
8061         if (temp2)
8062         delete arg2;
8063     }
8064     return resultobj;
8065     fail:
8066     {
8067         if (temp2)
8068         delete arg2;
8069     }
8070     return NULL;
8071 }
8072
8073
8074 static PyObject *_wrap_ListBox_IsSorted(PyObject *, PyObject *args, PyObject *kwargs) {
8075     PyObject *resultobj;
8076     wxListBox *arg1 = (wxListBox *) 0 ;
8077     bool result;
8078     PyObject * obj0 = 0 ;
8079     char *kwnames[] = {
8080         (char *) "self", NULL
8081     };
8082
8083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListBox_IsSorted",kwnames,&obj0)) goto fail;
8084     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8085     if (SWIG_arg_fail(1)) SWIG_fail;
8086     {
8087         PyThreadState* __tstate = wxPyBeginAllowThreads();
8088         result = (bool)((wxListBox const *)arg1)->IsSorted();
8089
8090         wxPyEndAllowThreads(__tstate);
8091         if (PyErr_Occurred()) SWIG_fail;
8092     }
8093     {
8094         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8095     }
8096     return resultobj;
8097     fail:
8098     return NULL;
8099 }
8100
8101
8102 static PyObject *_wrap_ListBox_SetItemForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8103     PyObject *resultobj;
8104     wxListBox *arg1 = (wxListBox *) 0 ;
8105     int arg2 ;
8106     wxColour *arg3 = 0 ;
8107     wxColour temp3 ;
8108     PyObject * obj0 = 0 ;
8109     PyObject * obj1 = 0 ;
8110     PyObject * obj2 = 0 ;
8111     char *kwnames[] = {
8112         (char *) "self",(char *) "item",(char *) "c", NULL
8113     };
8114
8115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemForegroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
8116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8117     if (SWIG_arg_fail(1)) SWIG_fail;
8118     {
8119         arg2 = (int)(SWIG_As_int(obj1));
8120         if (SWIG_arg_fail(2)) SWIG_fail;
8121     }
8122     {
8123         arg3 = &temp3;
8124         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8125     }
8126     {
8127         PyThreadState* __tstate = wxPyBeginAllowThreads();
8128         wxListBox_SetItemForegroundColour(arg1,arg2,(wxColour const &)*arg3);
8129
8130         wxPyEndAllowThreads(__tstate);
8131         if (PyErr_Occurred()) SWIG_fail;
8132     }
8133     Py_INCREF(Py_None); resultobj = Py_None;
8134     return resultobj;
8135     fail:
8136     return NULL;
8137 }
8138
8139
8140 static PyObject *_wrap_ListBox_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8141     PyObject *resultobj;
8142     wxListBox *arg1 = (wxListBox *) 0 ;
8143     int arg2 ;
8144     wxColour *arg3 = 0 ;
8145     wxColour temp3 ;
8146     PyObject * obj0 = 0 ;
8147     PyObject * obj1 = 0 ;
8148     PyObject * obj2 = 0 ;
8149     char *kwnames[] = {
8150         (char *) "self",(char *) "item",(char *) "c", NULL
8151     };
8152
8153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
8154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8155     if (SWIG_arg_fail(1)) SWIG_fail;
8156     {
8157         arg2 = (int)(SWIG_As_int(obj1));
8158         if (SWIG_arg_fail(2)) SWIG_fail;
8159     }
8160     {
8161         arg3 = &temp3;
8162         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8163     }
8164     {
8165         PyThreadState* __tstate = wxPyBeginAllowThreads();
8166         wxListBox_SetItemBackgroundColour(arg1,arg2,(wxColour const &)*arg3);
8167
8168         wxPyEndAllowThreads(__tstate);
8169         if (PyErr_Occurred()) SWIG_fail;
8170     }
8171     Py_INCREF(Py_None); resultobj = Py_None;
8172     return resultobj;
8173     fail:
8174     return NULL;
8175 }
8176
8177
8178 static PyObject *_wrap_ListBox_SetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
8179     PyObject *resultobj;
8180     wxListBox *arg1 = (wxListBox *) 0 ;
8181     int arg2 ;
8182     wxFont *arg3 = 0 ;
8183     PyObject * obj0 = 0 ;
8184     PyObject * obj1 = 0 ;
8185     PyObject * obj2 = 0 ;
8186     char *kwnames[] = {
8187         (char *) "self",(char *) "item",(char *) "f", NULL
8188     };
8189
8190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
8191     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListBox, SWIG_POINTER_EXCEPTION | 0);
8192     if (SWIG_arg_fail(1)) SWIG_fail;
8193     {
8194         arg2 = (int)(SWIG_As_int(obj1));
8195         if (SWIG_arg_fail(2)) SWIG_fail;
8196     }
8197     {
8198         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8199         if (SWIG_arg_fail(3)) SWIG_fail;
8200         if (arg3 == NULL) {
8201             SWIG_null_ref("wxFont");
8202         }
8203         if (SWIG_arg_fail(3)) SWIG_fail;
8204     }
8205     {
8206         PyThreadState* __tstate = wxPyBeginAllowThreads();
8207         wxListBox_SetItemFont(arg1,arg2,(wxFont const &)*arg3);
8208
8209         wxPyEndAllowThreads(__tstate);
8210         if (PyErr_Occurred()) SWIG_fail;
8211     }
8212     Py_INCREF(Py_None); resultobj = Py_None;
8213     return resultobj;
8214     fail:
8215     return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_ListBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8220     PyObject *resultobj;
8221     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8222     wxVisualAttributes result;
8223     PyObject * obj0 = 0 ;
8224     char *kwnames[] = {
8225         (char *) "variant", NULL
8226     };
8227
8228     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8229     if (obj0) {
8230         {
8231             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8232             if (SWIG_arg_fail(1)) SWIG_fail;
8233         }
8234     }
8235     {
8236         if (!wxPyCheckForApp()) SWIG_fail;
8237         PyThreadState* __tstate = wxPyBeginAllowThreads();
8238         result = wxListBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
8239
8240         wxPyEndAllowThreads(__tstate);
8241         if (PyErr_Occurred()) SWIG_fail;
8242     }
8243     {
8244         wxVisualAttributes * resultptr;
8245         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8246         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8247     }
8248     return resultobj;
8249     fail:
8250     return NULL;
8251 }
8252
8253
8254 static PyObject * ListBox_swigregister(PyObject *, PyObject *args) {
8255     PyObject *obj;
8256     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8257     SWIG_TypeClientData(SWIGTYPE_p_wxListBox, obj);
8258     Py_INCREF(obj);
8259     return Py_BuildValue((char *)"");
8260 }
8261 static PyObject *_wrap_new_CheckListBox(PyObject *, PyObject *args, PyObject *kwargs) {
8262     PyObject *resultobj;
8263     wxWindow *arg1 = (wxWindow *) 0 ;
8264     int arg2 = (int) -1 ;
8265     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8266     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8267     wxSize const &arg4_defvalue = wxDefaultSize ;
8268     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8269     wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
8270     wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
8271     long arg6 = (long) 0 ;
8272     wxValidator const &arg7_defvalue = wxDefaultValidator ;
8273     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
8274     wxString const &arg8_defvalue = wxPyListBoxNameStr ;
8275     wxString *arg8 = (wxString *) &arg8_defvalue ;
8276     wxCheckListBox *result;
8277     wxPoint temp3 ;
8278     wxSize temp4 ;
8279     bool temp5 = false ;
8280     bool temp8 = false ;
8281     PyObject * obj0 = 0 ;
8282     PyObject * obj1 = 0 ;
8283     PyObject * obj2 = 0 ;
8284     PyObject * obj3 = 0 ;
8285     PyObject * obj4 = 0 ;
8286     PyObject * obj5 = 0 ;
8287     PyObject * obj6 = 0 ;
8288     PyObject * obj7 = 0 ;
8289     char *kwnames[] = {
8290         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
8291     };
8292
8293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
8294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8295     if (SWIG_arg_fail(1)) SWIG_fail;
8296     if (obj1) {
8297         {
8298             arg2 = (int)(SWIG_As_int(obj1));
8299             if (SWIG_arg_fail(2)) SWIG_fail;
8300         }
8301     }
8302     if (obj2) {
8303         {
8304             arg3 = &temp3;
8305             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8306         }
8307     }
8308     if (obj3) {
8309         {
8310             arg4 = &temp4;
8311             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8312         }
8313     }
8314     if (obj4) {
8315         {
8316             if (! PySequence_Check(obj4)) {
8317                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
8318                 SWIG_fail;
8319             }
8320             arg5 = new wxArrayString;
8321             temp5 = true;
8322             int i, len=PySequence_Length(obj4);
8323             for (i=0; i<len; i++) {
8324                 PyObject* item = PySequence_GetItem(obj4, i);
8325 #if wxUSE_UNICODE
8326                 PyObject* str  = PyObject_Unicode(item);
8327 #else
8328                 PyObject* str  = PyObject_Str(item);
8329 #endif
8330                 if (PyErr_Occurred())  SWIG_fail;
8331                 arg5->Add(Py2wxString(str));
8332                 Py_DECREF(item);
8333                 Py_DECREF(str);
8334             }
8335         }
8336     }
8337     if (obj5) {
8338         {
8339             arg6 = (long)(SWIG_As_long(obj5));
8340             if (SWIG_arg_fail(6)) SWIG_fail;
8341         }
8342     }
8343     if (obj6) {
8344         {
8345             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
8346             if (SWIG_arg_fail(7)) SWIG_fail;
8347             if (arg7 == NULL) {
8348                 SWIG_null_ref("wxValidator");
8349             }
8350             if (SWIG_arg_fail(7)) SWIG_fail;
8351         }
8352     }
8353     if (obj7) {
8354         {
8355             arg8 = wxString_in_helper(obj7);
8356             if (arg8 == NULL) SWIG_fail;
8357             temp8 = true;
8358         }
8359     }
8360     {
8361         if (!wxPyCheckForApp()) SWIG_fail;
8362         PyThreadState* __tstate = wxPyBeginAllowThreads();
8363         result = (wxCheckListBox *)new wxCheckListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
8364
8365         wxPyEndAllowThreads(__tstate);
8366         if (PyErr_Occurred()) SWIG_fail;
8367     }
8368     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckListBox, 1);
8369     {
8370         if (temp5) delete arg5;
8371     }
8372     {
8373         if (temp8)
8374         delete arg8;
8375     }
8376     return resultobj;
8377     fail:
8378     {
8379         if (temp5) delete arg5;
8380     }
8381     {
8382         if (temp8)
8383         delete arg8;
8384     }
8385     return NULL;
8386 }
8387
8388
8389 static PyObject *_wrap_new_PreCheckListBox(PyObject *, PyObject *args, PyObject *kwargs) {
8390     PyObject *resultobj;
8391     wxCheckListBox *result;
8392     char *kwnames[] = {
8393         NULL
8394     };
8395
8396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreCheckListBox",kwnames)) goto fail;
8397     {
8398         if (!wxPyCheckForApp()) SWIG_fail;
8399         PyThreadState* __tstate = wxPyBeginAllowThreads();
8400         result = (wxCheckListBox *)new wxCheckListBox();
8401
8402         wxPyEndAllowThreads(__tstate);
8403         if (PyErr_Occurred()) SWIG_fail;
8404     }
8405     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCheckListBox, 1);
8406     return resultobj;
8407     fail:
8408     return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_CheckListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8413     PyObject *resultobj;
8414     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8415     wxWindow *arg2 = (wxWindow *) 0 ;
8416     int arg3 = (int) -1 ;
8417     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8418     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8419     wxSize const &arg5_defvalue = wxDefaultSize ;
8420     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8421     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
8422     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
8423     long arg7 = (long) 0 ;
8424     wxValidator const &arg8_defvalue = wxDefaultValidator ;
8425     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
8426     wxString const &arg9_defvalue = wxPyListBoxNameStr ;
8427     wxString *arg9 = (wxString *) &arg9_defvalue ;
8428     bool result;
8429     wxPoint temp4 ;
8430     wxSize temp5 ;
8431     bool temp6 = false ;
8432     bool temp9 = false ;
8433     PyObject * obj0 = 0 ;
8434     PyObject * obj1 = 0 ;
8435     PyObject * obj2 = 0 ;
8436     PyObject * obj3 = 0 ;
8437     PyObject * obj4 = 0 ;
8438     PyObject * obj5 = 0 ;
8439     PyObject * obj6 = 0 ;
8440     PyObject * obj7 = 0 ;
8441     PyObject * obj8 = 0 ;
8442     char *kwnames[] = {
8443         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL
8444     };
8445
8446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
8447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8448     if (SWIG_arg_fail(1)) SWIG_fail;
8449     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8450     if (SWIG_arg_fail(2)) SWIG_fail;
8451     if (obj2) {
8452         {
8453             arg3 = (int)(SWIG_As_int(obj2));
8454             if (SWIG_arg_fail(3)) SWIG_fail;
8455         }
8456     }
8457     if (obj3) {
8458         {
8459             arg4 = &temp4;
8460             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8461         }
8462     }
8463     if (obj4) {
8464         {
8465             arg5 = &temp5;
8466             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8467         }
8468     }
8469     if (obj5) {
8470         {
8471             if (! PySequence_Check(obj5)) {
8472                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
8473                 SWIG_fail;
8474             }
8475             arg6 = new wxArrayString;
8476             temp6 = true;
8477             int i, len=PySequence_Length(obj5);
8478             for (i=0; i<len; i++) {
8479                 PyObject* item = PySequence_GetItem(obj5, i);
8480 #if wxUSE_UNICODE
8481                 PyObject* str  = PyObject_Unicode(item);
8482 #else
8483                 PyObject* str  = PyObject_Str(item);
8484 #endif
8485                 if (PyErr_Occurred())  SWIG_fail;
8486                 arg6->Add(Py2wxString(str));
8487                 Py_DECREF(item);
8488                 Py_DECREF(str);
8489             }
8490         }
8491     }
8492     if (obj6) {
8493         {
8494             arg7 = (long)(SWIG_As_long(obj6));
8495             if (SWIG_arg_fail(7)) SWIG_fail;
8496         }
8497     }
8498     if (obj7) {
8499         {
8500             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
8501             if (SWIG_arg_fail(8)) SWIG_fail;
8502             if (arg8 == NULL) {
8503                 SWIG_null_ref("wxValidator");
8504             }
8505             if (SWIG_arg_fail(8)) SWIG_fail;
8506         }
8507     }
8508     if (obj8) {
8509         {
8510             arg9 = wxString_in_helper(obj8);
8511             if (arg9 == NULL) SWIG_fail;
8512             temp9 = true;
8513         }
8514     }
8515     {
8516         PyThreadState* __tstate = wxPyBeginAllowThreads();
8517         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
8518
8519         wxPyEndAllowThreads(__tstate);
8520         if (PyErr_Occurred()) SWIG_fail;
8521     }
8522     {
8523         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8524     }
8525     {
8526         if (temp6) delete arg6;
8527     }
8528     {
8529         if (temp9)
8530         delete arg9;
8531     }
8532     return resultobj;
8533     fail:
8534     {
8535         if (temp6) delete arg6;
8536     }
8537     {
8538         if (temp9)
8539         delete arg9;
8540     }
8541     return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_CheckListBox_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
8546     PyObject *resultobj;
8547     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8548     int arg2 ;
8549     bool result;
8550     PyObject * obj0 = 0 ;
8551     PyObject * obj1 = 0 ;
8552     char *kwnames[] = {
8553         (char *) "self",(char *) "index", NULL
8554     };
8555
8556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckListBox_IsChecked",kwnames,&obj0,&obj1)) goto fail;
8557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8558     if (SWIG_arg_fail(1)) SWIG_fail;
8559     {
8560         arg2 = (int)(SWIG_As_int(obj1));
8561         if (SWIG_arg_fail(2)) SWIG_fail;
8562     }
8563     {
8564         PyThreadState* __tstate = wxPyBeginAllowThreads();
8565         result = (bool)(arg1)->IsChecked(arg2);
8566
8567         wxPyEndAllowThreads(__tstate);
8568         if (PyErr_Occurred()) SWIG_fail;
8569     }
8570     {
8571         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8572     }
8573     return resultobj;
8574     fail:
8575     return NULL;
8576 }
8577
8578
8579 static PyObject *_wrap_CheckListBox_Check(PyObject *, PyObject *args, PyObject *kwargs) {
8580     PyObject *resultobj;
8581     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8582     int arg2 ;
8583     int arg3 = (int) true ;
8584     PyObject * obj0 = 0 ;
8585     PyObject * obj1 = 0 ;
8586     PyObject * obj2 = 0 ;
8587     char *kwnames[] = {
8588         (char *) "self",(char *) "index",(char *) "check", NULL
8589     };
8590
8591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:CheckListBox_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
8592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8593     if (SWIG_arg_fail(1)) SWIG_fail;
8594     {
8595         arg2 = (int)(SWIG_As_int(obj1));
8596         if (SWIG_arg_fail(2)) SWIG_fail;
8597     }
8598     if (obj2) {
8599         {
8600             arg3 = (int)(SWIG_As_int(obj2));
8601             if (SWIG_arg_fail(3)) SWIG_fail;
8602         }
8603     }
8604     {
8605         PyThreadState* __tstate = wxPyBeginAllowThreads();
8606         (arg1)->Check(arg2,arg3);
8607
8608         wxPyEndAllowThreads(__tstate);
8609         if (PyErr_Occurred()) SWIG_fail;
8610     }
8611     Py_INCREF(Py_None); resultobj = Py_None;
8612     return resultobj;
8613     fail:
8614     return NULL;
8615 }
8616
8617
8618 static PyObject *_wrap_CheckListBox_GetItemHeight(PyObject *, PyObject *args, PyObject *kwargs) {
8619     PyObject *resultobj;
8620     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8621     int result;
8622     PyObject * obj0 = 0 ;
8623     char *kwnames[] = {
8624         (char *) "self", NULL
8625     };
8626
8627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CheckListBox_GetItemHeight",kwnames,&obj0)) goto fail;
8628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8629     if (SWIG_arg_fail(1)) SWIG_fail;
8630     {
8631         PyThreadState* __tstate = wxPyBeginAllowThreads();
8632         result = (int)(arg1)->GetItemHeight();
8633
8634         wxPyEndAllowThreads(__tstate);
8635         if (PyErr_Occurred()) SWIG_fail;
8636     }
8637     {
8638         resultobj = SWIG_From_int((int)(result));
8639     }
8640     return resultobj;
8641     fail:
8642     return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_CheckListBox_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8647     PyObject *resultobj;
8648     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8649     wxPoint *arg2 = 0 ;
8650     int result;
8651     wxPoint temp2 ;
8652     PyObject * obj0 = 0 ;
8653     PyObject * obj1 = 0 ;
8654     char *kwnames[] = {
8655         (char *) "self",(char *) "pt", NULL
8656     };
8657
8658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckListBox_HitTest",kwnames,&obj0,&obj1)) goto fail;
8659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8660     if (SWIG_arg_fail(1)) SWIG_fail;
8661     {
8662         arg2 = &temp2;
8663         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8664     }
8665     {
8666         PyThreadState* __tstate = wxPyBeginAllowThreads();
8667         result = (int)((wxCheckListBox const *)arg1)->HitTest((wxPoint const &)*arg2);
8668
8669         wxPyEndAllowThreads(__tstate);
8670         if (PyErr_Occurred()) SWIG_fail;
8671     }
8672     {
8673         resultobj = SWIG_From_int((int)(result));
8674     }
8675     return resultobj;
8676     fail:
8677     return NULL;
8678 }
8679
8680
8681 static PyObject *_wrap_CheckListBox_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
8682     PyObject *resultobj;
8683     wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
8684     int arg2 ;
8685     int arg3 ;
8686     int result;
8687     PyObject * obj0 = 0 ;
8688     PyObject * obj1 = 0 ;
8689     PyObject * obj2 = 0 ;
8690     char *kwnames[] = {
8691         (char *) "self",(char *) "x",(char *) "y", NULL
8692     };
8693
8694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:CheckListBox_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
8695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_EXCEPTION | 0);
8696     if (SWIG_arg_fail(1)) SWIG_fail;
8697     {
8698         arg2 = (int)(SWIG_As_int(obj1));
8699         if (SWIG_arg_fail(2)) SWIG_fail;
8700     }
8701     {
8702         arg3 = (int)(SWIG_As_int(obj2));
8703         if (SWIG_arg_fail(3)) SWIG_fail;
8704     }
8705     {
8706         PyThreadState* __tstate = wxPyBeginAllowThreads();
8707         result = (int)((wxCheckListBox const *)arg1)->HitTest(arg2,arg3);
8708
8709         wxPyEndAllowThreads(__tstate);
8710         if (PyErr_Occurred()) SWIG_fail;
8711     }
8712     {
8713         resultobj = SWIG_From_int((int)(result));
8714     }
8715     return resultobj;
8716     fail:
8717     return NULL;
8718 }
8719
8720
8721 static PyObject * CheckListBox_swigregister(PyObject *, PyObject *args) {
8722     PyObject *obj;
8723     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8724     SWIG_TypeClientData(SWIGTYPE_p_wxCheckListBox, obj);
8725     Py_INCREF(obj);
8726     return Py_BuildValue((char *)"");
8727 }
8728 static int _wrap_TextCtrlNameStr_set(PyObject *) {
8729     PyErr_SetString(PyExc_TypeError,"Variable TextCtrlNameStr is read-only.");
8730     return 1;
8731 }
8732
8733
8734 static PyObject *_wrap_TextCtrlNameStr_get(void) {
8735     PyObject *pyobj;
8736
8737     {
8738 #if wxUSE_UNICODE
8739         pyobj = PyUnicode_FromWideChar((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
8740 #else
8741         pyobj = PyString_FromStringAndSize((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
8742 #endif
8743     }
8744     return pyobj;
8745 }
8746
8747
8748 static PyObject *_wrap_new_TextAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8749     PyObject *resultobj;
8750     wxColour const &arg1_defvalue = wxNullColour ;
8751     wxColour *arg1 = (wxColour *) &arg1_defvalue ;
8752     wxColour const &arg2_defvalue = wxNullColour ;
8753     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
8754     wxFont const &arg3_defvalue = wxNullFont ;
8755     wxFont *arg3 = (wxFont *) &arg3_defvalue ;
8756     wxTextAttrAlignment arg4 = (wxTextAttrAlignment) wxTEXT_ALIGNMENT_DEFAULT ;
8757     wxTextAttr *result;
8758     wxColour temp1 ;
8759     wxColour temp2 ;
8760     PyObject * obj0 = 0 ;
8761     PyObject * obj1 = 0 ;
8762     PyObject * obj2 = 0 ;
8763     PyObject * obj3 = 0 ;
8764     char *kwnames[] = {
8765         (char *) "colText",(char *) "colBack",(char *) "font",(char *) "alignment", NULL
8766     };
8767
8768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TextAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8769     if (obj0) {
8770         {
8771             arg1 = &temp1;
8772             if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
8773         }
8774     }
8775     if (obj1) {
8776         {
8777             arg2 = &temp2;
8778             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8779         }
8780     }
8781     if (obj2) {
8782         {
8783             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8784             if (SWIG_arg_fail(3)) SWIG_fail;
8785             if (arg3 == NULL) {
8786                 SWIG_null_ref("wxFont");
8787             }
8788             if (SWIG_arg_fail(3)) SWIG_fail;
8789         }
8790     }
8791     if (obj3) {
8792         {
8793             arg4 = (wxTextAttrAlignment)(SWIG_As_int(obj3));
8794             if (SWIG_arg_fail(4)) SWIG_fail;
8795         }
8796     }
8797     {
8798         PyThreadState* __tstate = wxPyBeginAllowThreads();
8799         result = (wxTextAttr *)new wxTextAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3,(wxTextAttrAlignment )arg4);
8800
8801         wxPyEndAllowThreads(__tstate);
8802         if (PyErr_Occurred()) SWIG_fail;
8803     }
8804     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextAttr, 1);
8805     return resultobj;
8806     fail:
8807     return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_delete_TextAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8812     PyObject *resultobj;
8813     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8814     PyObject * obj0 = 0 ;
8815     char *kwnames[] = {
8816         (char *) "self", NULL
8817     };
8818
8819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TextAttr",kwnames,&obj0)) goto fail;
8820     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8821     if (SWIG_arg_fail(1)) SWIG_fail;
8822     {
8823         PyThreadState* __tstate = wxPyBeginAllowThreads();
8824         delete arg1;
8825
8826         wxPyEndAllowThreads(__tstate);
8827         if (PyErr_Occurred()) SWIG_fail;
8828     }
8829     Py_INCREF(Py_None); resultobj = Py_None;
8830     return resultobj;
8831     fail:
8832     return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_TextAttr_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8837     PyObject *resultobj;
8838     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8839     PyObject * obj0 = 0 ;
8840     char *kwnames[] = {
8841         (char *) "self", NULL
8842     };
8843
8844     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_Init",kwnames,&obj0)) goto fail;
8845     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8846     if (SWIG_arg_fail(1)) SWIG_fail;
8847     {
8848         PyThreadState* __tstate = wxPyBeginAllowThreads();
8849         (arg1)->Init();
8850
8851         wxPyEndAllowThreads(__tstate);
8852         if (PyErr_Occurred()) SWIG_fail;
8853     }
8854     Py_INCREF(Py_None); resultobj = Py_None;
8855     return resultobj;
8856     fail:
8857     return NULL;
8858 }
8859
8860
8861 static PyObject *_wrap_TextAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
8862     PyObject *resultobj;
8863     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8864     wxColour *arg2 = 0 ;
8865     wxColour temp2 ;
8866     PyObject * obj0 = 0 ;
8867     PyObject * obj1 = 0 ;
8868     char *kwnames[] = {
8869         (char *) "self",(char *) "colText", NULL
8870     };
8871
8872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
8873     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8874     if (SWIG_arg_fail(1)) SWIG_fail;
8875     {
8876         arg2 = &temp2;
8877         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8878     }
8879     {
8880         PyThreadState* __tstate = wxPyBeginAllowThreads();
8881         (arg1)->SetTextColour((wxColour const &)*arg2);
8882
8883         wxPyEndAllowThreads(__tstate);
8884         if (PyErr_Occurred()) SWIG_fail;
8885     }
8886     Py_INCREF(Py_None); resultobj = Py_None;
8887     return resultobj;
8888     fail:
8889     return NULL;
8890 }
8891
8892
8893 static PyObject *_wrap_TextAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
8894     PyObject *resultobj;
8895     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8896     wxColour *arg2 = 0 ;
8897     wxColour temp2 ;
8898     PyObject * obj0 = 0 ;
8899     PyObject * obj1 = 0 ;
8900     char *kwnames[] = {
8901         (char *) "self",(char *) "colBack", NULL
8902     };
8903
8904     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
8905     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8906     if (SWIG_arg_fail(1)) SWIG_fail;
8907     {
8908         arg2 = &temp2;
8909         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8910     }
8911     {
8912         PyThreadState* __tstate = wxPyBeginAllowThreads();
8913         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
8914
8915         wxPyEndAllowThreads(__tstate);
8916         if (PyErr_Occurred()) SWIG_fail;
8917     }
8918     Py_INCREF(Py_None); resultobj = Py_None;
8919     return resultobj;
8920     fail:
8921     return NULL;
8922 }
8923
8924
8925 static PyObject *_wrap_TextAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
8926     PyObject *resultobj;
8927     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8928     wxFont *arg2 = 0 ;
8929     long arg3 = (long) wxTEXT_ATTR_FONT ;
8930     PyObject * obj0 = 0 ;
8931     PyObject * obj1 = 0 ;
8932     PyObject * obj2 = 0 ;
8933     char *kwnames[] = {
8934         (char *) "self",(char *) "font",(char *) "flags", NULL
8935     };
8936
8937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
8938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8939     if (SWIG_arg_fail(1)) SWIG_fail;
8940     {
8941         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8942         if (SWIG_arg_fail(2)) SWIG_fail;
8943         if (arg2 == NULL) {
8944             SWIG_null_ref("wxFont");
8945         }
8946         if (SWIG_arg_fail(2)) SWIG_fail;
8947     }
8948     if (obj2) {
8949         {
8950             arg3 = (long)(SWIG_As_long(obj2));
8951             if (SWIG_arg_fail(3)) SWIG_fail;
8952         }
8953     }
8954     {
8955         PyThreadState* __tstate = wxPyBeginAllowThreads();
8956         (arg1)->SetFont((wxFont const &)*arg2,arg3);
8957
8958         wxPyEndAllowThreads(__tstate);
8959         if (PyErr_Occurred()) SWIG_fail;
8960     }
8961     Py_INCREF(Py_None); resultobj = Py_None;
8962     return resultobj;
8963     fail:
8964     return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_TextAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
8969     PyObject *resultobj;
8970     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
8971     wxTextAttrAlignment arg2 ;
8972     PyObject * obj0 = 0 ;
8973     PyObject * obj1 = 0 ;
8974     char *kwnames[] = {
8975         (char *) "self",(char *) "alignment", NULL
8976     };
8977
8978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
8979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
8980     if (SWIG_arg_fail(1)) SWIG_fail;
8981     {
8982         arg2 = (wxTextAttrAlignment)(SWIG_As_int(obj1));
8983         if (SWIG_arg_fail(2)) SWIG_fail;
8984     }
8985     {
8986         PyThreadState* __tstate = wxPyBeginAllowThreads();
8987         (arg1)->SetAlignment((wxTextAttrAlignment )arg2);
8988
8989         wxPyEndAllowThreads(__tstate);
8990         if (PyErr_Occurred()) SWIG_fail;
8991     }
8992     Py_INCREF(Py_None); resultobj = Py_None;
8993     return resultobj;
8994     fail:
8995     return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_TextAttr_SetTabs(PyObject *, PyObject *args, PyObject *kwargs) {
9000     PyObject *resultobj;
9001     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9002     wxArrayInt *arg2 = 0 ;
9003     bool temp2 = false ;
9004     PyObject * obj0 = 0 ;
9005     PyObject * obj1 = 0 ;
9006     char *kwnames[] = {
9007         (char *) "self",(char *) "tabs", NULL
9008     };
9009
9010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTabs",kwnames,&obj0,&obj1)) goto fail;
9011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9012     if (SWIG_arg_fail(1)) SWIG_fail;
9013     {
9014         if (! PySequence_Check(obj1)) {
9015             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
9016             SWIG_fail;
9017         }
9018         arg2 = new wxArrayInt;
9019         temp2 = true;
9020         int i, len=PySequence_Length(obj1);
9021         for (i=0; i<len; i++) {
9022             PyObject* item = PySequence_GetItem(obj1, i);
9023             PyObject* number  = PyNumber_Int(item);
9024             arg2->Add(PyInt_AS_LONG(number));
9025             Py_DECREF(item);
9026             Py_DECREF(number);
9027         }
9028     }
9029     {
9030         PyThreadState* __tstate = wxPyBeginAllowThreads();
9031         (arg1)->SetTabs((wxArrayInt const &)*arg2);
9032
9033         wxPyEndAllowThreads(__tstate);
9034         if (PyErr_Occurred()) SWIG_fail;
9035     }
9036     Py_INCREF(Py_None); resultobj = Py_None;
9037     {
9038         if (temp2) delete arg2;
9039     }
9040     return resultobj;
9041     fail:
9042     {
9043         if (temp2) delete arg2;
9044     }
9045     return NULL;
9046 }
9047
9048
9049 static PyObject *_wrap_TextAttr_SetLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9050     PyObject *resultobj;
9051     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9052     int arg2 ;
9053     int arg3 = (int) 0 ;
9054     PyObject * obj0 = 0 ;
9055     PyObject * obj1 = 0 ;
9056     PyObject * obj2 = 0 ;
9057     char *kwnames[] = {
9058         (char *) "self",(char *) "indent",(char *) "subIndent", NULL
9059     };
9060
9061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetLeftIndent",kwnames,&obj0,&obj1,&obj2)) goto fail;
9062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9063     if (SWIG_arg_fail(1)) SWIG_fail;
9064     {
9065         arg2 = (int)(SWIG_As_int(obj1));
9066         if (SWIG_arg_fail(2)) SWIG_fail;
9067     }
9068     if (obj2) {
9069         {
9070             arg3 = (int)(SWIG_As_int(obj2));
9071             if (SWIG_arg_fail(3)) SWIG_fail;
9072         }
9073     }
9074     {
9075         PyThreadState* __tstate = wxPyBeginAllowThreads();
9076         (arg1)->SetLeftIndent(arg2,arg3);
9077
9078         wxPyEndAllowThreads(__tstate);
9079         if (PyErr_Occurred()) SWIG_fail;
9080     }
9081     Py_INCREF(Py_None); resultobj = Py_None;
9082     return resultobj;
9083     fail:
9084     return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_TextAttr_SetRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9089     PyObject *resultobj;
9090     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9091     int arg2 ;
9092     PyObject * obj0 = 0 ;
9093     PyObject * obj1 = 0 ;
9094     char *kwnames[] = {
9095         (char *) "self",(char *) "indent", NULL
9096     };
9097
9098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetRightIndent",kwnames,&obj0,&obj1)) goto fail;
9099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9100     if (SWIG_arg_fail(1)) SWIG_fail;
9101     {
9102         arg2 = (int)(SWIG_As_int(obj1));
9103         if (SWIG_arg_fail(2)) SWIG_fail;
9104     }
9105     {
9106         PyThreadState* __tstate = wxPyBeginAllowThreads();
9107         (arg1)->SetRightIndent(arg2);
9108
9109         wxPyEndAllowThreads(__tstate);
9110         if (PyErr_Occurred()) SWIG_fail;
9111     }
9112     Py_INCREF(Py_None); resultobj = Py_None;
9113     return resultobj;
9114     fail:
9115     return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_TextAttr_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9120     PyObject *resultobj;
9121     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9122     long arg2 ;
9123     PyObject * obj0 = 0 ;
9124     PyObject * obj1 = 0 ;
9125     char *kwnames[] = {
9126         (char *) "self",(char *) "flags", NULL
9127     };
9128
9129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9131     if (SWIG_arg_fail(1)) SWIG_fail;
9132     {
9133         arg2 = (long)(SWIG_As_long(obj1));
9134         if (SWIG_arg_fail(2)) SWIG_fail;
9135     }
9136     {
9137         PyThreadState* __tstate = wxPyBeginAllowThreads();
9138         (arg1)->SetFlags(arg2);
9139
9140         wxPyEndAllowThreads(__tstate);
9141         if (PyErr_Occurred()) SWIG_fail;
9142     }
9143     Py_INCREF(Py_None); resultobj = Py_None;
9144     return resultobj;
9145     fail:
9146     return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_TextAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
9151     PyObject *resultobj;
9152     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9153     bool result;
9154     PyObject * obj0 = 0 ;
9155     char *kwnames[] = {
9156         (char *) "self", NULL
9157     };
9158
9159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasTextColour",kwnames,&obj0)) goto fail;
9160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9161     if (SWIG_arg_fail(1)) SWIG_fail;
9162     {
9163         PyThreadState* __tstate = wxPyBeginAllowThreads();
9164         result = (bool)((wxTextAttr const *)arg1)->HasTextColour();
9165
9166         wxPyEndAllowThreads(__tstate);
9167         if (PyErr_Occurred()) SWIG_fail;
9168     }
9169     {
9170         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9171     }
9172     return resultobj;
9173     fail:
9174     return NULL;
9175 }
9176
9177
9178 static PyObject *_wrap_TextAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
9179     PyObject *resultobj;
9180     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9181     bool result;
9182     PyObject * obj0 = 0 ;
9183     char *kwnames[] = {
9184         (char *) "self", NULL
9185     };
9186
9187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
9188     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9189     if (SWIG_arg_fail(1)) SWIG_fail;
9190     {
9191         PyThreadState* __tstate = wxPyBeginAllowThreads();
9192         result = (bool)((wxTextAttr const *)arg1)->HasBackgroundColour();
9193
9194         wxPyEndAllowThreads(__tstate);
9195         if (PyErr_Occurred()) SWIG_fail;
9196     }
9197     {
9198         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9199     }
9200     return resultobj;
9201     fail:
9202     return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_TextAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
9207     PyObject *resultobj;
9208     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9209     bool result;
9210     PyObject * obj0 = 0 ;
9211     char *kwnames[] = {
9212         (char *) "self", NULL
9213     };
9214
9215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasFont",kwnames,&obj0)) goto fail;
9216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9217     if (SWIG_arg_fail(1)) SWIG_fail;
9218     {
9219         PyThreadState* __tstate = wxPyBeginAllowThreads();
9220         result = (bool)((wxTextAttr const *)arg1)->HasFont();
9221
9222         wxPyEndAllowThreads(__tstate);
9223         if (PyErr_Occurred()) SWIG_fail;
9224     }
9225     {
9226         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9227     }
9228     return resultobj;
9229     fail:
9230     return NULL;
9231 }
9232
9233
9234 static PyObject *_wrap_TextAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9235     PyObject *resultobj;
9236     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9237     bool result;
9238     PyObject * obj0 = 0 ;
9239     char *kwnames[] = {
9240         (char *) "self", NULL
9241     };
9242
9243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasAlignment",kwnames,&obj0)) goto fail;
9244     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9245     if (SWIG_arg_fail(1)) SWIG_fail;
9246     {
9247         PyThreadState* __tstate = wxPyBeginAllowThreads();
9248         result = (bool)((wxTextAttr const *)arg1)->HasAlignment();
9249
9250         wxPyEndAllowThreads(__tstate);
9251         if (PyErr_Occurred()) SWIG_fail;
9252     }
9253     {
9254         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9255     }
9256     return resultobj;
9257     fail:
9258     return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_TextAttr_HasTabs(PyObject *, PyObject *args, PyObject *kwargs) {
9263     PyObject *resultobj;
9264     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9265     bool result;
9266     PyObject * obj0 = 0 ;
9267     char *kwnames[] = {
9268         (char *) "self", NULL
9269     };
9270
9271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasTabs",kwnames,&obj0)) goto fail;
9272     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9273     if (SWIG_arg_fail(1)) SWIG_fail;
9274     {
9275         PyThreadState* __tstate = wxPyBeginAllowThreads();
9276         result = (bool)((wxTextAttr const *)arg1)->HasTabs();
9277
9278         wxPyEndAllowThreads(__tstate);
9279         if (PyErr_Occurred()) SWIG_fail;
9280     }
9281     {
9282         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9283     }
9284     return resultobj;
9285     fail:
9286     return NULL;
9287 }
9288
9289
9290 static PyObject *_wrap_TextAttr_HasLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9291     PyObject *resultobj;
9292     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9293     bool result;
9294     PyObject * obj0 = 0 ;
9295     char *kwnames[] = {
9296         (char *) "self", NULL
9297     };
9298
9299     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasLeftIndent",kwnames,&obj0)) goto fail;
9300     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9301     if (SWIG_arg_fail(1)) SWIG_fail;
9302     {
9303         PyThreadState* __tstate = wxPyBeginAllowThreads();
9304         result = (bool)((wxTextAttr const *)arg1)->HasLeftIndent();
9305
9306         wxPyEndAllowThreads(__tstate);
9307         if (PyErr_Occurred()) SWIG_fail;
9308     }
9309     {
9310         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9311     }
9312     return resultobj;
9313     fail:
9314     return NULL;
9315 }
9316
9317
9318 static PyObject *_wrap_TextAttr_HasRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9319     PyObject *resultobj;
9320     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9321     bool result;
9322     PyObject * obj0 = 0 ;
9323     char *kwnames[] = {
9324         (char *) "self", NULL
9325     };
9326
9327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_HasRightIndent",kwnames,&obj0)) goto fail;
9328     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9329     if (SWIG_arg_fail(1)) SWIG_fail;
9330     {
9331         PyThreadState* __tstate = wxPyBeginAllowThreads();
9332         result = (bool)((wxTextAttr const *)arg1)->HasRightIndent();
9333
9334         wxPyEndAllowThreads(__tstate);
9335         if (PyErr_Occurred()) SWIG_fail;
9336     }
9337     {
9338         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9339     }
9340     return resultobj;
9341     fail:
9342     return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_TextAttr_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
9347     PyObject *resultobj;
9348     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9349     long arg2 ;
9350     bool result;
9351     PyObject * obj0 = 0 ;
9352     PyObject * obj1 = 0 ;
9353     char *kwnames[] = {
9354         (char *) "self",(char *) "flag", NULL
9355     };
9356
9357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_HasFlag",kwnames,&obj0,&obj1)) goto fail;
9358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9359     if (SWIG_arg_fail(1)) SWIG_fail;
9360     {
9361         arg2 = (long)(SWIG_As_long(obj1));
9362         if (SWIG_arg_fail(2)) SWIG_fail;
9363     }
9364     {
9365         PyThreadState* __tstate = wxPyBeginAllowThreads();
9366         result = (bool)((wxTextAttr const *)arg1)->HasFlag(arg2);
9367
9368         wxPyEndAllowThreads(__tstate);
9369         if (PyErr_Occurred()) SWIG_fail;
9370     }
9371     {
9372         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9373     }
9374     return resultobj;
9375     fail:
9376     return NULL;
9377 }
9378
9379
9380 static PyObject *_wrap_TextAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
9381     PyObject *resultobj;
9382     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9383     wxColour *result;
9384     PyObject * obj0 = 0 ;
9385     char *kwnames[] = {
9386         (char *) "self", NULL
9387     };
9388
9389     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetTextColour",kwnames,&obj0)) goto fail;
9390     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9391     if (SWIG_arg_fail(1)) SWIG_fail;
9392     {
9393         PyThreadState* __tstate = wxPyBeginAllowThreads();
9394         {
9395             wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetTextColour();
9396             result = (wxColour *) &_result_ref;
9397         }
9398
9399         wxPyEndAllowThreads(__tstate);
9400         if (PyErr_Occurred()) SWIG_fail;
9401     }
9402     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
9403     return resultobj;
9404     fail:
9405     return NULL;
9406 }
9407
9408
9409 static PyObject *_wrap_TextAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
9410     PyObject *resultobj;
9411     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9412     wxColour *result;
9413     PyObject * obj0 = 0 ;
9414     char *kwnames[] = {
9415         (char *) "self", NULL
9416     };
9417
9418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
9419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9420     if (SWIG_arg_fail(1)) SWIG_fail;
9421     {
9422         PyThreadState* __tstate = wxPyBeginAllowThreads();
9423         {
9424             wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetBackgroundColour();
9425             result = (wxColour *) &_result_ref;
9426         }
9427
9428         wxPyEndAllowThreads(__tstate);
9429         if (PyErr_Occurred()) SWIG_fail;
9430     }
9431     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
9432     return resultobj;
9433     fail:
9434     return NULL;
9435 }
9436
9437
9438 static PyObject *_wrap_TextAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
9439     PyObject *resultobj;
9440     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9441     wxFont *result;
9442     PyObject * obj0 = 0 ;
9443     char *kwnames[] = {
9444         (char *) "self", NULL
9445     };
9446
9447     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetFont",kwnames,&obj0)) goto fail;
9448     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9449     if (SWIG_arg_fail(1)) SWIG_fail;
9450     {
9451         PyThreadState* __tstate = wxPyBeginAllowThreads();
9452         {
9453             wxFont const &_result_ref = ((wxTextAttr const *)arg1)->GetFont();
9454             result = (wxFont *) &_result_ref;
9455         }
9456
9457         wxPyEndAllowThreads(__tstate);
9458         if (PyErr_Occurred()) SWIG_fail;
9459     }
9460     {
9461         wxFont* resultptr = new wxFont(*result);
9462         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
9463     }
9464     return resultobj;
9465     fail:
9466     return NULL;
9467 }
9468
9469
9470 static PyObject *_wrap_TextAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9471     PyObject *resultobj;
9472     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9473     wxTextAttrAlignment result;
9474     PyObject * obj0 = 0 ;
9475     char *kwnames[] = {
9476         (char *) "self", NULL
9477     };
9478
9479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetAlignment",kwnames,&obj0)) goto fail;
9480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9481     if (SWIG_arg_fail(1)) SWIG_fail;
9482     {
9483         PyThreadState* __tstate = wxPyBeginAllowThreads();
9484         result = (wxTextAttrAlignment)((wxTextAttr const *)arg1)->GetAlignment();
9485
9486         wxPyEndAllowThreads(__tstate);
9487         if (PyErr_Occurred()) SWIG_fail;
9488     }
9489     resultobj = SWIG_From_int((result));
9490     return resultobj;
9491     fail:
9492     return NULL;
9493 }
9494
9495
9496 static PyObject *_wrap_TextAttr_GetTabs(PyObject *, PyObject *args, PyObject *kwargs) {
9497     PyObject *resultobj;
9498     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9499     wxArrayInt *result;
9500     PyObject * obj0 = 0 ;
9501     char *kwnames[] = {
9502         (char *) "self", NULL
9503     };
9504
9505     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetTabs",kwnames,&obj0)) goto fail;
9506     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9507     if (SWIG_arg_fail(1)) SWIG_fail;
9508     {
9509         PyThreadState* __tstate = wxPyBeginAllowThreads();
9510         {
9511             wxArrayInt const &_result_ref = ((wxTextAttr const *)arg1)->GetTabs();
9512             result = (wxArrayInt *) &_result_ref;
9513         }
9514
9515         wxPyEndAllowThreads(__tstate);
9516         if (PyErr_Occurred()) SWIG_fail;
9517     }
9518     {
9519         resultobj = PyList_New(0);
9520         size_t idx;
9521         for (idx = 0; idx < result->GetCount(); idx += 1) {
9522             PyObject* val = PyInt_FromLong( result->Item(idx) );
9523             PyList_Append(resultobj, val);
9524             Py_DECREF(val);
9525         }
9526     }
9527     return resultobj;
9528     fail:
9529     return NULL;
9530 }
9531
9532
9533 static PyObject *_wrap_TextAttr_GetLeftIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9534     PyObject *resultobj;
9535     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9536     long result;
9537     PyObject * obj0 = 0 ;
9538     char *kwnames[] = {
9539         (char *) "self", NULL
9540     };
9541
9542     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetLeftIndent",kwnames,&obj0)) goto fail;
9543     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9544     if (SWIG_arg_fail(1)) SWIG_fail;
9545     {
9546         PyThreadState* __tstate = wxPyBeginAllowThreads();
9547         result = (long)((wxTextAttr const *)arg1)->GetLeftIndent();
9548
9549         wxPyEndAllowThreads(__tstate);
9550         if (PyErr_Occurred()) SWIG_fail;
9551     }
9552     {
9553         resultobj = SWIG_From_long((long)(result));
9554     }
9555     return resultobj;
9556     fail:
9557     return NULL;
9558 }
9559
9560
9561 static PyObject *_wrap_TextAttr_GetLeftSubIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9562     PyObject *resultobj;
9563     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9564     long result;
9565     PyObject * obj0 = 0 ;
9566     char *kwnames[] = {
9567         (char *) "self", NULL
9568     };
9569
9570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetLeftSubIndent",kwnames,&obj0)) goto fail;
9571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9572     if (SWIG_arg_fail(1)) SWIG_fail;
9573     {
9574         PyThreadState* __tstate = wxPyBeginAllowThreads();
9575         result = (long)((wxTextAttr const *)arg1)->GetLeftSubIndent();
9576
9577         wxPyEndAllowThreads(__tstate);
9578         if (PyErr_Occurred()) SWIG_fail;
9579     }
9580     {
9581         resultobj = SWIG_From_long((long)(result));
9582     }
9583     return resultobj;
9584     fail:
9585     return NULL;
9586 }
9587
9588
9589 static PyObject *_wrap_TextAttr_GetRightIndent(PyObject *, PyObject *args, PyObject *kwargs) {
9590     PyObject *resultobj;
9591     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9592     long result;
9593     PyObject * obj0 = 0 ;
9594     char *kwnames[] = {
9595         (char *) "self", NULL
9596     };
9597
9598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetRightIndent",kwnames,&obj0)) goto fail;
9599     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9600     if (SWIG_arg_fail(1)) SWIG_fail;
9601     {
9602         PyThreadState* __tstate = wxPyBeginAllowThreads();
9603         result = (long)((wxTextAttr const *)arg1)->GetRightIndent();
9604
9605         wxPyEndAllowThreads(__tstate);
9606         if (PyErr_Occurred()) SWIG_fail;
9607     }
9608     {
9609         resultobj = SWIG_From_long((long)(result));
9610     }
9611     return resultobj;
9612     fail:
9613     return NULL;
9614 }
9615
9616
9617 static PyObject *_wrap_TextAttr_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9618     PyObject *resultobj;
9619     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9620     long result;
9621     PyObject * obj0 = 0 ;
9622     char *kwnames[] = {
9623         (char *) "self", NULL
9624     };
9625
9626     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_GetFlags",kwnames,&obj0)) goto fail;
9627     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9628     if (SWIG_arg_fail(1)) SWIG_fail;
9629     {
9630         PyThreadState* __tstate = wxPyBeginAllowThreads();
9631         result = (long)((wxTextAttr const *)arg1)->GetFlags();
9632
9633         wxPyEndAllowThreads(__tstate);
9634         if (PyErr_Occurred()) SWIG_fail;
9635     }
9636     {
9637         resultobj = SWIG_From_long((long)(result));
9638     }
9639     return resultobj;
9640     fail:
9641     return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_TextAttr_IsDefault(PyObject *, PyObject *args, PyObject *kwargs) {
9646     PyObject *resultobj;
9647     wxTextAttr *arg1 = (wxTextAttr *) 0 ;
9648     bool result;
9649     PyObject * obj0 = 0 ;
9650     char *kwnames[] = {
9651         (char *) "self", NULL
9652     };
9653
9654     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextAttr_IsDefault",kwnames,&obj0)) goto fail;
9655     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9656     if (SWIG_arg_fail(1)) SWIG_fail;
9657     {
9658         PyThreadState* __tstate = wxPyBeginAllowThreads();
9659         result = (bool)((wxTextAttr const *)arg1)->IsDefault();
9660
9661         wxPyEndAllowThreads(__tstate);
9662         if (PyErr_Occurred()) SWIG_fail;
9663     }
9664     {
9665         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9666     }
9667     return resultobj;
9668     fail:
9669     return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_TextAttr_Combine(PyObject *, PyObject *args, PyObject *kwargs) {
9674     PyObject *resultobj;
9675     wxTextAttr *arg1 = 0 ;
9676     wxTextAttr *arg2 = 0 ;
9677     wxTextCtrl *arg3 = (wxTextCtrl *) 0 ;
9678     wxTextAttr result;
9679     PyObject * obj0 = 0 ;
9680     PyObject * obj1 = 0 ;
9681     PyObject * obj2 = 0 ;
9682     char *kwnames[] = {
9683         (char *) "attr",(char *) "attrDef",(char *) "text", NULL
9684     };
9685
9686     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttr_Combine",kwnames,&obj0,&obj1,&obj2)) goto fail;
9687     {
9688         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9689         if (SWIG_arg_fail(1)) SWIG_fail;
9690         if (arg1 == NULL) {
9691             SWIG_null_ref("wxTextAttr");
9692         }
9693         if (SWIG_arg_fail(1)) SWIG_fail;
9694     }
9695     {
9696         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
9697         if (SWIG_arg_fail(2)) SWIG_fail;
9698         if (arg2 == NULL) {
9699             SWIG_null_ref("wxTextAttr");
9700         }
9701         if (SWIG_arg_fail(2)) SWIG_fail;
9702     }
9703     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9704     if (SWIG_arg_fail(3)) SWIG_fail;
9705     {
9706         PyThreadState* __tstate = wxPyBeginAllowThreads();
9707         result = wxTextAttr::Combine((wxTextAttr const &)*arg1,(wxTextAttr const &)*arg2,(wxTextCtrl const *)arg3);
9708
9709         wxPyEndAllowThreads(__tstate);
9710         if (PyErr_Occurred()) SWIG_fail;
9711     }
9712     {
9713         wxTextAttr * resultptr;
9714         resultptr = new wxTextAttr((wxTextAttr &)(result));
9715         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTextAttr, 1);
9716     }
9717     return resultobj;
9718     fail:
9719     return NULL;
9720 }
9721
9722
9723 static PyObject * TextAttr_swigregister(PyObject *, PyObject *args) {
9724     PyObject *obj;
9725     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9726     SWIG_TypeClientData(SWIGTYPE_p_wxTextAttr, obj);
9727     Py_INCREF(obj);
9728     return Py_BuildValue((char *)"");
9729 }
9730 static PyObject *_wrap_new_TextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9731     PyObject *resultobj;
9732     wxWindow *arg1 = (wxWindow *) 0 ;
9733     int arg2 = (int) -1 ;
9734     wxString const &arg3_defvalue = wxPyEmptyString ;
9735     wxString *arg3 = (wxString *) &arg3_defvalue ;
9736     wxPoint const &arg4_defvalue = wxDefaultPosition ;
9737     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9738     wxSize const &arg5_defvalue = wxDefaultSize ;
9739     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9740     long arg6 = (long) 0 ;
9741     wxValidator const &arg7_defvalue = wxDefaultValidator ;
9742     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
9743     wxString const &arg8_defvalue = wxPyTextCtrlNameStr ;
9744     wxString *arg8 = (wxString *) &arg8_defvalue ;
9745     wxTextCtrl *result;
9746     bool temp3 = false ;
9747     wxPoint temp4 ;
9748     wxSize temp5 ;
9749     bool temp8 = false ;
9750     PyObject * obj0 = 0 ;
9751     PyObject * obj1 = 0 ;
9752     PyObject * obj2 = 0 ;
9753     PyObject * obj3 = 0 ;
9754     PyObject * obj4 = 0 ;
9755     PyObject * obj5 = 0 ;
9756     PyObject * obj6 = 0 ;
9757     PyObject * obj7 = 0 ;
9758     char *kwnames[] = {
9759         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
9760     };
9761
9762     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_TextCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
9763     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9764     if (SWIG_arg_fail(1)) SWIG_fail;
9765     if (obj1) {
9766         {
9767             arg2 = (int)(SWIG_As_int(obj1));
9768             if (SWIG_arg_fail(2)) SWIG_fail;
9769         }
9770     }
9771     if (obj2) {
9772         {
9773             arg3 = wxString_in_helper(obj2);
9774             if (arg3 == NULL) SWIG_fail;
9775             temp3 = true;
9776         }
9777     }
9778     if (obj3) {
9779         {
9780             arg4 = &temp4;
9781             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9782         }
9783     }
9784     if (obj4) {
9785         {
9786             arg5 = &temp5;
9787             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9788         }
9789     }
9790     if (obj5) {
9791         {
9792             arg6 = (long)(SWIG_As_long(obj5));
9793             if (SWIG_arg_fail(6)) SWIG_fail;
9794         }
9795     }
9796     if (obj6) {
9797         {
9798             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
9799             if (SWIG_arg_fail(7)) SWIG_fail;
9800             if (arg7 == NULL) {
9801                 SWIG_null_ref("wxValidator");
9802             }
9803             if (SWIG_arg_fail(7)) SWIG_fail;
9804         }
9805     }
9806     if (obj7) {
9807         {
9808             arg8 = wxString_in_helper(obj7);
9809             if (arg8 == NULL) SWIG_fail;
9810             temp8 = true;
9811         }
9812     }
9813     {
9814         if (!wxPyCheckForApp()) SWIG_fail;
9815         PyThreadState* __tstate = wxPyBeginAllowThreads();
9816         result = (wxTextCtrl *)new wxTextCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
9817
9818         wxPyEndAllowThreads(__tstate);
9819         if (PyErr_Occurred()) SWIG_fail;
9820     }
9821     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextCtrl, 1);
9822     {
9823         if (temp3)
9824         delete arg3;
9825     }
9826     {
9827         if (temp8)
9828         delete arg8;
9829     }
9830     return resultobj;
9831     fail:
9832     {
9833         if (temp3)
9834         delete arg3;
9835     }
9836     {
9837         if (temp8)
9838         delete arg8;
9839     }
9840     return NULL;
9841 }
9842
9843
9844 static PyObject *_wrap_new_PreTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9845     PyObject *resultobj;
9846     wxTextCtrl *result;
9847     char *kwnames[] = {
9848         NULL
9849     };
9850
9851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreTextCtrl",kwnames)) goto fail;
9852     {
9853         if (!wxPyCheckForApp()) SWIG_fail;
9854         PyThreadState* __tstate = wxPyBeginAllowThreads();
9855         result = (wxTextCtrl *)new wxTextCtrl();
9856
9857         wxPyEndAllowThreads(__tstate);
9858         if (PyErr_Occurred()) SWIG_fail;
9859     }
9860     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextCtrl, 1);
9861     return resultobj;
9862     fail:
9863     return NULL;
9864 }
9865
9866
9867 static PyObject *_wrap_TextCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9868     PyObject *resultobj;
9869     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9870     wxWindow *arg2 = (wxWindow *) 0 ;
9871     int arg3 = (int) -1 ;
9872     wxString const &arg4_defvalue = wxPyEmptyString ;
9873     wxString *arg4 = (wxString *) &arg4_defvalue ;
9874     wxPoint const &arg5_defvalue = wxDefaultPosition ;
9875     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
9876     wxSize const &arg6_defvalue = wxDefaultSize ;
9877     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
9878     long arg7 = (long) 0 ;
9879     wxValidator const &arg8_defvalue = wxDefaultValidator ;
9880     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
9881     wxString const &arg9_defvalue = wxPyTextCtrlNameStr ;
9882     wxString *arg9 = (wxString *) &arg9_defvalue ;
9883     bool result;
9884     bool temp4 = false ;
9885     wxPoint temp5 ;
9886     wxSize temp6 ;
9887     bool temp9 = false ;
9888     PyObject * obj0 = 0 ;
9889     PyObject * obj1 = 0 ;
9890     PyObject * obj2 = 0 ;
9891     PyObject * obj3 = 0 ;
9892     PyObject * obj4 = 0 ;
9893     PyObject * obj5 = 0 ;
9894     PyObject * obj6 = 0 ;
9895     PyObject * obj7 = 0 ;
9896     PyObject * obj8 = 0 ;
9897     char *kwnames[] = {
9898         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
9899     };
9900
9901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:TextCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
9902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9903     if (SWIG_arg_fail(1)) SWIG_fail;
9904     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9905     if (SWIG_arg_fail(2)) SWIG_fail;
9906     if (obj2) {
9907         {
9908             arg3 = (int)(SWIG_As_int(obj2));
9909             if (SWIG_arg_fail(3)) SWIG_fail;
9910         }
9911     }
9912     if (obj3) {
9913         {
9914             arg4 = wxString_in_helper(obj3);
9915             if (arg4 == NULL) SWIG_fail;
9916             temp4 = true;
9917         }
9918     }
9919     if (obj4) {
9920         {
9921             arg5 = &temp5;
9922             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
9923         }
9924     }
9925     if (obj5) {
9926         {
9927             arg6 = &temp6;
9928             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
9929         }
9930     }
9931     if (obj6) {
9932         {
9933             arg7 = (long)(SWIG_As_long(obj6));
9934             if (SWIG_arg_fail(7)) SWIG_fail;
9935         }
9936     }
9937     if (obj7) {
9938         {
9939             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
9940             if (SWIG_arg_fail(8)) SWIG_fail;
9941             if (arg8 == NULL) {
9942                 SWIG_null_ref("wxValidator");
9943             }
9944             if (SWIG_arg_fail(8)) SWIG_fail;
9945         }
9946     }
9947     if (obj8) {
9948         {
9949             arg9 = wxString_in_helper(obj8);
9950             if (arg9 == NULL) SWIG_fail;
9951             temp9 = true;
9952         }
9953     }
9954     {
9955         PyThreadState* __tstate = wxPyBeginAllowThreads();
9956         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
9957
9958         wxPyEndAllowThreads(__tstate);
9959         if (PyErr_Occurred()) SWIG_fail;
9960     }
9961     {
9962         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9963     }
9964     {
9965         if (temp4)
9966         delete arg4;
9967     }
9968     {
9969         if (temp9)
9970         delete arg9;
9971     }
9972     return resultobj;
9973     fail:
9974     {
9975         if (temp4)
9976         delete arg4;
9977     }
9978     {
9979         if (temp9)
9980         delete arg9;
9981     }
9982     return NULL;
9983 }
9984
9985
9986 static PyObject *_wrap_TextCtrl_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
9987     PyObject *resultobj;
9988     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9989     wxString result;
9990     PyObject * obj0 = 0 ;
9991     char *kwnames[] = {
9992         (char *) "self", NULL
9993     };
9994
9995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetValue",kwnames,&obj0)) goto fail;
9996     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9997     if (SWIG_arg_fail(1)) SWIG_fail;
9998     {
9999         PyThreadState* __tstate = wxPyBeginAllowThreads();
10000         result = ((wxTextCtrl const *)arg1)->GetValue();
10001
10002         wxPyEndAllowThreads(__tstate);
10003         if (PyErr_Occurred()) SWIG_fail;
10004     }
10005     {
10006 #if wxUSE_UNICODE
10007         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10008 #else
10009         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10010 #endif
10011     }
10012     return resultobj;
10013     fail:
10014     return NULL;
10015 }
10016
10017
10018 static PyObject *_wrap_TextCtrl_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
10019     PyObject *resultobj;
10020     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10021     wxString *arg2 = 0 ;
10022     bool temp2 = false ;
10023     PyObject * obj0 = 0 ;
10024     PyObject * obj1 = 0 ;
10025     char *kwnames[] = {
10026         (char *) "self",(char *) "value", NULL
10027     };
10028
10029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetValue",kwnames,&obj0,&obj1)) goto fail;
10030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10031     if (SWIG_arg_fail(1)) SWIG_fail;
10032     {
10033         arg2 = wxString_in_helper(obj1);
10034         if (arg2 == NULL) SWIG_fail;
10035         temp2 = true;
10036     }
10037     {
10038         PyThreadState* __tstate = wxPyBeginAllowThreads();
10039         (arg1)->SetValue((wxString const &)*arg2);
10040
10041         wxPyEndAllowThreads(__tstate);
10042         if (PyErr_Occurred()) SWIG_fail;
10043     }
10044     Py_INCREF(Py_None); resultobj = Py_None;
10045     {
10046         if (temp2)
10047         delete arg2;
10048     }
10049     return resultobj;
10050     fail:
10051     {
10052         if (temp2)
10053         delete arg2;
10054     }
10055     return NULL;
10056 }
10057
10058
10059 static PyObject *_wrap_TextCtrl_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
10060     PyObject *resultobj;
10061     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10062     long arg2 ;
10063     long arg3 ;
10064     wxString result;
10065     PyObject * obj0 = 0 ;
10066     PyObject * obj1 = 0 ;
10067     PyObject * obj2 = 0 ;
10068     char *kwnames[] = {
10069         (char *) "self",(char *) "from",(char *) "to", NULL
10070     };
10071
10072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
10073     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10074     if (SWIG_arg_fail(1)) SWIG_fail;
10075     {
10076         arg2 = (long)(SWIG_As_long(obj1));
10077         if (SWIG_arg_fail(2)) SWIG_fail;
10078     }
10079     {
10080         arg3 = (long)(SWIG_As_long(obj2));
10081         if (SWIG_arg_fail(3)) SWIG_fail;
10082     }
10083     {
10084         PyThreadState* __tstate = wxPyBeginAllowThreads();
10085         result = ((wxTextCtrl const *)arg1)->GetRange(arg2,arg3);
10086
10087         wxPyEndAllowThreads(__tstate);
10088         if (PyErr_Occurred()) SWIG_fail;
10089     }
10090     {
10091 #if wxUSE_UNICODE
10092         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10093 #else
10094         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10095 #endif
10096     }
10097     return resultobj;
10098     fail:
10099     return NULL;
10100 }
10101
10102
10103 static PyObject *_wrap_TextCtrl_GetLineLength(PyObject *, PyObject *args, PyObject *kwargs) {
10104     PyObject *resultobj;
10105     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10106     long arg2 ;
10107     int result;
10108     PyObject * obj0 = 0 ;
10109     PyObject * obj1 = 0 ;
10110     char *kwnames[] = {
10111         (char *) "self",(char *) "lineNo", NULL
10112     };
10113
10114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_GetLineLength",kwnames,&obj0,&obj1)) goto fail;
10115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10116     if (SWIG_arg_fail(1)) SWIG_fail;
10117     {
10118         arg2 = (long)(SWIG_As_long(obj1));
10119         if (SWIG_arg_fail(2)) SWIG_fail;
10120     }
10121     {
10122         PyThreadState* __tstate = wxPyBeginAllowThreads();
10123         result = (int)((wxTextCtrl const *)arg1)->GetLineLength(arg2);
10124
10125         wxPyEndAllowThreads(__tstate);
10126         if (PyErr_Occurred()) SWIG_fail;
10127     }
10128     {
10129         resultobj = SWIG_From_int((int)(result));
10130     }
10131     return resultobj;
10132     fail:
10133     return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_TextCtrl_GetLineText(PyObject *, PyObject *args, PyObject *kwargs) {
10138     PyObject *resultobj;
10139     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10140     long arg2 ;
10141     wxString result;
10142     PyObject * obj0 = 0 ;
10143     PyObject * obj1 = 0 ;
10144     char *kwnames[] = {
10145         (char *) "self",(char *) "lineNo", NULL
10146     };
10147
10148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_GetLineText",kwnames,&obj0,&obj1)) goto fail;
10149     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10150     if (SWIG_arg_fail(1)) SWIG_fail;
10151     {
10152         arg2 = (long)(SWIG_As_long(obj1));
10153         if (SWIG_arg_fail(2)) SWIG_fail;
10154     }
10155     {
10156         PyThreadState* __tstate = wxPyBeginAllowThreads();
10157         result = ((wxTextCtrl const *)arg1)->GetLineText(arg2);
10158
10159         wxPyEndAllowThreads(__tstate);
10160         if (PyErr_Occurred()) SWIG_fail;
10161     }
10162     {
10163 #if wxUSE_UNICODE
10164         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10165 #else
10166         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10167 #endif
10168     }
10169     return resultobj;
10170     fail:
10171     return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_TextCtrl_GetNumberOfLines(PyObject *, PyObject *args, PyObject *kwargs) {
10176     PyObject *resultobj;
10177     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10178     int result;
10179     PyObject * obj0 = 0 ;
10180     char *kwnames[] = {
10181         (char *) "self", NULL
10182     };
10183
10184     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetNumberOfLines",kwnames,&obj0)) goto fail;
10185     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10186     if (SWIG_arg_fail(1)) SWIG_fail;
10187     {
10188         PyThreadState* __tstate = wxPyBeginAllowThreads();
10189         result = (int)((wxTextCtrl const *)arg1)->GetNumberOfLines();
10190
10191         wxPyEndAllowThreads(__tstate);
10192         if (PyErr_Occurred()) SWIG_fail;
10193     }
10194     {
10195         resultobj = SWIG_From_int((int)(result));
10196     }
10197     return resultobj;
10198     fail:
10199     return NULL;
10200 }
10201
10202
10203 static PyObject *_wrap_TextCtrl_IsModified(PyObject *, PyObject *args, PyObject *kwargs) {
10204     PyObject *resultobj;
10205     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10206     bool result;
10207     PyObject * obj0 = 0 ;
10208     char *kwnames[] = {
10209         (char *) "self", NULL
10210     };
10211
10212     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsModified",kwnames,&obj0)) goto fail;
10213     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10214     if (SWIG_arg_fail(1)) SWIG_fail;
10215     {
10216         PyThreadState* __tstate = wxPyBeginAllowThreads();
10217         result = (bool)((wxTextCtrl const *)arg1)->IsModified();
10218
10219         wxPyEndAllowThreads(__tstate);
10220         if (PyErr_Occurred()) SWIG_fail;
10221     }
10222     {
10223         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10224     }
10225     return resultobj;
10226     fail:
10227     return NULL;
10228 }
10229
10230
10231 static PyObject *_wrap_TextCtrl_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10232     PyObject *resultobj;
10233     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10234     bool result;
10235     PyObject * obj0 = 0 ;
10236     char *kwnames[] = {
10237         (char *) "self", NULL
10238     };
10239
10240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsEditable",kwnames,&obj0)) goto fail;
10241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10242     if (SWIG_arg_fail(1)) SWIG_fail;
10243     {
10244         PyThreadState* __tstate = wxPyBeginAllowThreads();
10245         result = (bool)((wxTextCtrl const *)arg1)->IsEditable();
10246
10247         wxPyEndAllowThreads(__tstate);
10248         if (PyErr_Occurred()) SWIG_fail;
10249     }
10250     {
10251         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10252     }
10253     return resultobj;
10254     fail:
10255     return NULL;
10256 }
10257
10258
10259 static PyObject *_wrap_TextCtrl_IsSingleLine(PyObject *, PyObject *args, PyObject *kwargs) {
10260     PyObject *resultobj;
10261     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10262     bool result;
10263     PyObject * obj0 = 0 ;
10264     char *kwnames[] = {
10265         (char *) "self", NULL
10266     };
10267
10268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsSingleLine",kwnames,&obj0)) goto fail;
10269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10270     if (SWIG_arg_fail(1)) SWIG_fail;
10271     {
10272         PyThreadState* __tstate = wxPyBeginAllowThreads();
10273         result = (bool)((wxTextCtrl const *)arg1)->IsSingleLine();
10274
10275         wxPyEndAllowThreads(__tstate);
10276         if (PyErr_Occurred()) SWIG_fail;
10277     }
10278     {
10279         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10280     }
10281     return resultobj;
10282     fail:
10283     return NULL;
10284 }
10285
10286
10287 static PyObject *_wrap_TextCtrl_IsMultiLine(PyObject *, PyObject *args, PyObject *kwargs) {
10288     PyObject *resultobj;
10289     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10290     bool result;
10291     PyObject * obj0 = 0 ;
10292     char *kwnames[] = {
10293         (char *) "self", NULL
10294     };
10295
10296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_IsMultiLine",kwnames,&obj0)) goto fail;
10297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10298     if (SWIG_arg_fail(1)) SWIG_fail;
10299     {
10300         PyThreadState* __tstate = wxPyBeginAllowThreads();
10301         result = (bool)((wxTextCtrl const *)arg1)->IsMultiLine();
10302
10303         wxPyEndAllowThreads(__tstate);
10304         if (PyErr_Occurred()) SWIG_fail;
10305     }
10306     {
10307         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10308     }
10309     return resultobj;
10310     fail:
10311     return NULL;
10312 }
10313
10314
10315 static PyObject *_wrap_TextCtrl_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
10316     PyObject *resultobj;
10317     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10318     long *arg2 = (long *) 0 ;
10319     long *arg3 = (long *) 0 ;
10320     long temp2 ;
10321     int res2 = 0 ;
10322     long temp3 ;
10323     int res3 = 0 ;
10324     PyObject * obj0 = 0 ;
10325     char *kwnames[] = {
10326         (char *) "self", NULL
10327     };
10328
10329     arg2 = &temp2; res2 = SWIG_NEWOBJ;
10330     arg3 = &temp3; res3 = SWIG_NEWOBJ;
10331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetSelection",kwnames,&obj0)) goto fail;
10332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10333     if (SWIG_arg_fail(1)) SWIG_fail;
10334     {
10335         PyThreadState* __tstate = wxPyBeginAllowThreads();
10336         ((wxTextCtrl const *)arg1)->GetSelection(arg2,arg3);
10337
10338         wxPyEndAllowThreads(__tstate);
10339         if (PyErr_Occurred()) SWIG_fail;
10340     }
10341     Py_INCREF(Py_None); resultobj = Py_None;
10342     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10343     SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
10344     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10345     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
10346     return resultobj;
10347     fail:
10348     return NULL;
10349 }
10350
10351
10352 static PyObject *_wrap_TextCtrl_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
10353     PyObject *resultobj;
10354     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10355     wxString result;
10356     PyObject * obj0 = 0 ;
10357     char *kwnames[] = {
10358         (char *) "self", NULL
10359     };
10360
10361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetStringSelection",kwnames,&obj0)) goto fail;
10362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10363     if (SWIG_arg_fail(1)) SWIG_fail;
10364     {
10365         PyThreadState* __tstate = wxPyBeginAllowThreads();
10366         result = ((wxTextCtrl const *)arg1)->GetStringSelection();
10367
10368         wxPyEndAllowThreads(__tstate);
10369         if (PyErr_Occurred()) SWIG_fail;
10370     }
10371     {
10372 #if wxUSE_UNICODE
10373         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10374 #else
10375         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10376 #endif
10377     }
10378     return resultobj;
10379     fail:
10380     return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_TextCtrl_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
10385     PyObject *resultobj;
10386     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10387     PyObject * obj0 = 0 ;
10388     char *kwnames[] = {
10389         (char *) "self", NULL
10390     };
10391
10392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Clear",kwnames,&obj0)) goto fail;
10393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10394     if (SWIG_arg_fail(1)) SWIG_fail;
10395     {
10396         PyThreadState* __tstate = wxPyBeginAllowThreads();
10397         (arg1)->Clear();
10398
10399         wxPyEndAllowThreads(__tstate);
10400         if (PyErr_Occurred()) SWIG_fail;
10401     }
10402     Py_INCREF(Py_None); resultobj = Py_None;
10403     return resultobj;
10404     fail:
10405     return NULL;
10406 }
10407
10408
10409 static PyObject *_wrap_TextCtrl_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
10410     PyObject *resultobj;
10411     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10412     long arg2 ;
10413     long arg3 ;
10414     wxString *arg4 = 0 ;
10415     bool temp4 = false ;
10416     PyObject * obj0 = 0 ;
10417     PyObject * obj1 = 0 ;
10418     PyObject * obj2 = 0 ;
10419     PyObject * obj3 = 0 ;
10420     char *kwnames[] = {
10421         (char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL
10422     };
10423
10424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextCtrl_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10426     if (SWIG_arg_fail(1)) SWIG_fail;
10427     {
10428         arg2 = (long)(SWIG_As_long(obj1));
10429         if (SWIG_arg_fail(2)) SWIG_fail;
10430     }
10431     {
10432         arg3 = (long)(SWIG_As_long(obj2));
10433         if (SWIG_arg_fail(3)) SWIG_fail;
10434     }
10435     {
10436         arg4 = wxString_in_helper(obj3);
10437         if (arg4 == NULL) SWIG_fail;
10438         temp4 = true;
10439     }
10440     {
10441         PyThreadState* __tstate = wxPyBeginAllowThreads();
10442         (arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
10443
10444         wxPyEndAllowThreads(__tstate);
10445         if (PyErr_Occurred()) SWIG_fail;
10446     }
10447     Py_INCREF(Py_None); resultobj = Py_None;
10448     {
10449         if (temp4)
10450         delete arg4;
10451     }
10452     return resultobj;
10453     fail:
10454     {
10455         if (temp4)
10456         delete arg4;
10457     }
10458     return NULL;
10459 }
10460
10461
10462 static PyObject *_wrap_TextCtrl_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
10463     PyObject *resultobj;
10464     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10465     long arg2 ;
10466     long arg3 ;
10467     PyObject * obj0 = 0 ;
10468     PyObject * obj1 = 0 ;
10469     PyObject * obj2 = 0 ;
10470     char *kwnames[] = {
10471         (char *) "self",(char *) "from",(char *) "to", NULL
10472     };
10473
10474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_Remove",kwnames,&obj0,&obj1,&obj2)) goto fail;
10475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10476     if (SWIG_arg_fail(1)) SWIG_fail;
10477     {
10478         arg2 = (long)(SWIG_As_long(obj1));
10479         if (SWIG_arg_fail(2)) SWIG_fail;
10480     }
10481     {
10482         arg3 = (long)(SWIG_As_long(obj2));
10483         if (SWIG_arg_fail(3)) SWIG_fail;
10484     }
10485     {
10486         PyThreadState* __tstate = wxPyBeginAllowThreads();
10487         (arg1)->Remove(arg2,arg3);
10488
10489         wxPyEndAllowThreads(__tstate);
10490         if (PyErr_Occurred()) SWIG_fail;
10491     }
10492     Py_INCREF(Py_None); resultobj = Py_None;
10493     return resultobj;
10494     fail:
10495     return NULL;
10496 }
10497
10498
10499 static PyObject *_wrap_TextCtrl_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
10500     PyObject *resultobj;
10501     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10502     wxString *arg2 = 0 ;
10503     bool result;
10504     bool temp2 = false ;
10505     PyObject * obj0 = 0 ;
10506     PyObject * obj1 = 0 ;
10507     char *kwnames[] = {
10508         (char *) "self",(char *) "file", NULL
10509     };
10510
10511     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_LoadFile",kwnames,&obj0,&obj1)) goto fail;
10512     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10513     if (SWIG_arg_fail(1)) SWIG_fail;
10514     {
10515         arg2 = wxString_in_helper(obj1);
10516         if (arg2 == NULL) SWIG_fail;
10517         temp2 = true;
10518     }
10519     {
10520         PyThreadState* __tstate = wxPyBeginAllowThreads();
10521         result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
10522
10523         wxPyEndAllowThreads(__tstate);
10524         if (PyErr_Occurred()) SWIG_fail;
10525     }
10526     {
10527         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10528     }
10529     {
10530         if (temp2)
10531         delete arg2;
10532     }
10533     return resultobj;
10534     fail:
10535     {
10536         if (temp2)
10537         delete arg2;
10538     }
10539     return NULL;
10540 }
10541
10542
10543 static PyObject *_wrap_TextCtrl_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
10544     PyObject *resultobj;
10545     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10546     wxString const &arg2_defvalue = wxPyEmptyString ;
10547     wxString *arg2 = (wxString *) &arg2_defvalue ;
10548     bool result;
10549     bool temp2 = false ;
10550     PyObject * obj0 = 0 ;
10551     PyObject * obj1 = 0 ;
10552     char *kwnames[] = {
10553         (char *) "self",(char *) "file", NULL
10554     };
10555
10556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TextCtrl_SaveFile",kwnames,&obj0,&obj1)) goto fail;
10557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10558     if (SWIG_arg_fail(1)) SWIG_fail;
10559     if (obj1) {
10560         {
10561             arg2 = wxString_in_helper(obj1);
10562             if (arg2 == NULL) SWIG_fail;
10563             temp2 = true;
10564         }
10565     }
10566     {
10567         PyThreadState* __tstate = wxPyBeginAllowThreads();
10568         result = (bool)(arg1)->SaveFile((wxString const &)*arg2);
10569
10570         wxPyEndAllowThreads(__tstate);
10571         if (PyErr_Occurred()) SWIG_fail;
10572     }
10573     {
10574         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10575     }
10576     {
10577         if (temp2)
10578         delete arg2;
10579     }
10580     return resultobj;
10581     fail:
10582     {
10583         if (temp2)
10584         delete arg2;
10585     }
10586     return NULL;
10587 }
10588
10589
10590 static PyObject *_wrap_TextCtrl_MarkDirty(PyObject *, PyObject *args, PyObject *kwargs) {
10591     PyObject *resultobj;
10592     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10593     PyObject * obj0 = 0 ;
10594     char *kwnames[] = {
10595         (char *) "self", NULL
10596     };
10597
10598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_MarkDirty",kwnames,&obj0)) goto fail;
10599     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10600     if (SWIG_arg_fail(1)) SWIG_fail;
10601     {
10602         PyThreadState* __tstate = wxPyBeginAllowThreads();
10603         (arg1)->MarkDirty();
10604
10605         wxPyEndAllowThreads(__tstate);
10606         if (PyErr_Occurred()) SWIG_fail;
10607     }
10608     Py_INCREF(Py_None); resultobj = Py_None;
10609     return resultobj;
10610     fail:
10611     return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_TextCtrl_DiscardEdits(PyObject *, PyObject *args, PyObject *kwargs) {
10616     PyObject *resultobj;
10617     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10618     PyObject * obj0 = 0 ;
10619     char *kwnames[] = {
10620         (char *) "self", NULL
10621     };
10622
10623     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_DiscardEdits",kwnames,&obj0)) goto fail;
10624     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10625     if (SWIG_arg_fail(1)) SWIG_fail;
10626     {
10627         PyThreadState* __tstate = wxPyBeginAllowThreads();
10628         (arg1)->DiscardEdits();
10629
10630         wxPyEndAllowThreads(__tstate);
10631         if (PyErr_Occurred()) SWIG_fail;
10632     }
10633     Py_INCREF(Py_None); resultobj = Py_None;
10634     return resultobj;
10635     fail:
10636     return NULL;
10637 }
10638
10639
10640 static PyObject *_wrap_TextCtrl_SetMaxLength(PyObject *, PyObject *args, PyObject *kwargs) {
10641     PyObject *resultobj;
10642     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10643     unsigned long arg2 ;
10644     PyObject * obj0 = 0 ;
10645     PyObject * obj1 = 0 ;
10646     char *kwnames[] = {
10647         (char *) "self",(char *) "len", NULL
10648     };
10649
10650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetMaxLength",kwnames,&obj0,&obj1)) goto fail;
10651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10652     if (SWIG_arg_fail(1)) SWIG_fail;
10653     {
10654         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10655         if (SWIG_arg_fail(2)) SWIG_fail;
10656     }
10657     {
10658         PyThreadState* __tstate = wxPyBeginAllowThreads();
10659         (arg1)->SetMaxLength(arg2);
10660
10661         wxPyEndAllowThreads(__tstate);
10662         if (PyErr_Occurred()) SWIG_fail;
10663     }
10664     Py_INCREF(Py_None); resultobj = Py_None;
10665     return resultobj;
10666     fail:
10667     return NULL;
10668 }
10669
10670
10671 static PyObject *_wrap_TextCtrl_WriteText(PyObject *, PyObject *args, PyObject *kwargs) {
10672     PyObject *resultobj;
10673     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10674     wxString *arg2 = 0 ;
10675     bool temp2 = false ;
10676     PyObject * obj0 = 0 ;
10677     PyObject * obj1 = 0 ;
10678     char *kwnames[] = {
10679         (char *) "self",(char *) "text", NULL
10680     };
10681
10682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_WriteText",kwnames,&obj0,&obj1)) goto fail;
10683     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10684     if (SWIG_arg_fail(1)) SWIG_fail;
10685     {
10686         arg2 = wxString_in_helper(obj1);
10687         if (arg2 == NULL) SWIG_fail;
10688         temp2 = true;
10689     }
10690     {
10691         PyThreadState* __tstate = wxPyBeginAllowThreads();
10692         (arg1)->WriteText((wxString const &)*arg2);
10693
10694         wxPyEndAllowThreads(__tstate);
10695         if (PyErr_Occurred()) SWIG_fail;
10696     }
10697     Py_INCREF(Py_None); resultobj = Py_None;
10698     {
10699         if (temp2)
10700         delete arg2;
10701     }
10702     return resultobj;
10703     fail:
10704     {
10705         if (temp2)
10706         delete arg2;
10707     }
10708     return NULL;
10709 }
10710
10711
10712 static PyObject *_wrap_TextCtrl_AppendText(PyObject *, PyObject *args, PyObject *kwargs) {
10713     PyObject *resultobj;
10714     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10715     wxString *arg2 = 0 ;
10716     bool temp2 = false ;
10717     PyObject * obj0 = 0 ;
10718     PyObject * obj1 = 0 ;
10719     char *kwnames[] = {
10720         (char *) "self",(char *) "text", NULL
10721     };
10722
10723     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_AppendText",kwnames,&obj0,&obj1)) goto fail;
10724     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10725     if (SWIG_arg_fail(1)) SWIG_fail;
10726     {
10727         arg2 = wxString_in_helper(obj1);
10728         if (arg2 == NULL) SWIG_fail;
10729         temp2 = true;
10730     }
10731     {
10732         PyThreadState* __tstate = wxPyBeginAllowThreads();
10733         (arg1)->AppendText((wxString const &)*arg2);
10734
10735         wxPyEndAllowThreads(__tstate);
10736         if (PyErr_Occurred()) SWIG_fail;
10737     }
10738     Py_INCREF(Py_None); resultobj = Py_None;
10739     {
10740         if (temp2)
10741         delete arg2;
10742     }
10743     return resultobj;
10744     fail:
10745     {
10746         if (temp2)
10747         delete arg2;
10748     }
10749     return NULL;
10750 }
10751
10752
10753 static PyObject *_wrap_TextCtrl_EmulateKeyPress(PyObject *, PyObject *args, PyObject *kwargs) {
10754     PyObject *resultobj;
10755     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10756     wxKeyEvent *arg2 = 0 ;
10757     bool result;
10758     PyObject * obj0 = 0 ;
10759     PyObject * obj1 = 0 ;
10760     char *kwnames[] = {
10761         (char *) "self",(char *) "event", NULL
10762     };
10763
10764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_EmulateKeyPress",kwnames,&obj0,&obj1)) goto fail;
10765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10766     if (SWIG_arg_fail(1)) SWIG_fail;
10767     {
10768         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
10769         if (SWIG_arg_fail(2)) SWIG_fail;
10770         if (arg2 == NULL) {
10771             SWIG_null_ref("wxKeyEvent");
10772         }
10773         if (SWIG_arg_fail(2)) SWIG_fail;
10774     }
10775     {
10776         PyThreadState* __tstate = wxPyBeginAllowThreads();
10777         result = (bool)(arg1)->EmulateKeyPress((wxKeyEvent const &)*arg2);
10778
10779         wxPyEndAllowThreads(__tstate);
10780         if (PyErr_Occurred()) SWIG_fail;
10781     }
10782     {
10783         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10784     }
10785     return resultobj;
10786     fail:
10787     return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_TextCtrl_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10792     PyObject *resultobj;
10793     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10794     long arg2 ;
10795     long arg3 ;
10796     wxTextAttr *arg4 = 0 ;
10797     bool result;
10798     PyObject * obj0 = 0 ;
10799     PyObject * obj1 = 0 ;
10800     PyObject * obj2 = 0 ;
10801     PyObject * obj3 = 0 ;
10802     char *kwnames[] = {
10803         (char *) "self",(char *) "start",(char *) "end",(char *) "style", NULL
10804     };
10805
10806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextCtrl_SetStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10808     if (SWIG_arg_fail(1)) SWIG_fail;
10809     {
10810         arg2 = (long)(SWIG_As_long(obj1));
10811         if (SWIG_arg_fail(2)) SWIG_fail;
10812     }
10813     {
10814         arg3 = (long)(SWIG_As_long(obj2));
10815         if (SWIG_arg_fail(3)) SWIG_fail;
10816     }
10817     {
10818         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10819         if (SWIG_arg_fail(4)) SWIG_fail;
10820         if (arg4 == NULL) {
10821             SWIG_null_ref("wxTextAttr");
10822         }
10823         if (SWIG_arg_fail(4)) SWIG_fail;
10824     }
10825     {
10826         PyThreadState* __tstate = wxPyBeginAllowThreads();
10827         result = (bool)(arg1)->SetStyle(arg2,arg3,(wxTextAttr const &)*arg4);
10828
10829         wxPyEndAllowThreads(__tstate);
10830         if (PyErr_Occurred()) SWIG_fail;
10831     }
10832     {
10833         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10834     }
10835     return resultobj;
10836     fail:
10837     return NULL;
10838 }
10839
10840
10841 static PyObject *_wrap_TextCtrl_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10842     PyObject *resultobj;
10843     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10844     long arg2 ;
10845     wxTextAttr *arg3 = 0 ;
10846     bool result;
10847     PyObject * obj0 = 0 ;
10848     PyObject * obj1 = 0 ;
10849     PyObject * obj2 = 0 ;
10850     char *kwnames[] = {
10851         (char *) "self",(char *) "position",(char *) "style", NULL
10852     };
10853
10854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
10855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10856     if (SWIG_arg_fail(1)) SWIG_fail;
10857     {
10858         arg2 = (long)(SWIG_As_long(obj1));
10859         if (SWIG_arg_fail(2)) SWIG_fail;
10860     }
10861     {
10862         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10863         if (SWIG_arg_fail(3)) SWIG_fail;
10864         if (arg3 == NULL) {
10865             SWIG_null_ref("wxTextAttr");
10866         }
10867         if (SWIG_arg_fail(3)) SWIG_fail;
10868     }
10869     {
10870         PyThreadState* __tstate = wxPyBeginAllowThreads();
10871         result = (bool)(arg1)->GetStyle(arg2,*arg3);
10872
10873         wxPyEndAllowThreads(__tstate);
10874         if (PyErr_Occurred()) SWIG_fail;
10875     }
10876     {
10877         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10878     }
10879     return resultobj;
10880     fail:
10881     return NULL;
10882 }
10883
10884
10885 static PyObject *_wrap_TextCtrl_SetDefaultStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10886     PyObject *resultobj;
10887     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10888     wxTextAttr *arg2 = 0 ;
10889     bool result;
10890     PyObject * obj0 = 0 ;
10891     PyObject * obj1 = 0 ;
10892     char *kwnames[] = {
10893         (char *) "self",(char *) "style", NULL
10894     };
10895
10896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetDefaultStyle",kwnames,&obj0,&obj1)) goto fail;
10897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10898     if (SWIG_arg_fail(1)) SWIG_fail;
10899     {
10900         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTextAttr, SWIG_POINTER_EXCEPTION | 0);
10901         if (SWIG_arg_fail(2)) SWIG_fail;
10902         if (arg2 == NULL) {
10903             SWIG_null_ref("wxTextAttr");
10904         }
10905         if (SWIG_arg_fail(2)) SWIG_fail;
10906     }
10907     {
10908         PyThreadState* __tstate = wxPyBeginAllowThreads();
10909         result = (bool)(arg1)->SetDefaultStyle((wxTextAttr const &)*arg2);
10910
10911         wxPyEndAllowThreads(__tstate);
10912         if (PyErr_Occurred()) SWIG_fail;
10913     }
10914     {
10915         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10916     }
10917     return resultobj;
10918     fail:
10919     return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_TextCtrl_GetDefaultStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10924     PyObject *resultobj;
10925     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10926     wxTextAttr *result;
10927     PyObject * obj0 = 0 ;
10928     char *kwnames[] = {
10929         (char *) "self", NULL
10930     };
10931
10932     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetDefaultStyle",kwnames,&obj0)) goto fail;
10933     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10934     if (SWIG_arg_fail(1)) SWIG_fail;
10935     {
10936         PyThreadState* __tstate = wxPyBeginAllowThreads();
10937         {
10938             wxTextAttr const &_result_ref = ((wxTextCtrl const *)arg1)->GetDefaultStyle();
10939             result = (wxTextAttr *) &_result_ref;
10940         }
10941
10942         wxPyEndAllowThreads(__tstate);
10943         if (PyErr_Occurred()) SWIG_fail;
10944     }
10945     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextAttr, 0);
10946     return resultobj;
10947     fail:
10948     return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_TextCtrl_XYToPosition(PyObject *, PyObject *args, PyObject *kwargs) {
10953     PyObject *resultobj;
10954     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10955     long arg2 ;
10956     long arg3 ;
10957     long result;
10958     PyObject * obj0 = 0 ;
10959     PyObject * obj1 = 0 ;
10960     PyObject * obj2 = 0 ;
10961     char *kwnames[] = {
10962         (char *) "self",(char *) "x",(char *) "y", NULL
10963     };
10964
10965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_XYToPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
10966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10967     if (SWIG_arg_fail(1)) SWIG_fail;
10968     {
10969         arg2 = (long)(SWIG_As_long(obj1));
10970         if (SWIG_arg_fail(2)) SWIG_fail;
10971     }
10972     {
10973         arg3 = (long)(SWIG_As_long(obj2));
10974         if (SWIG_arg_fail(3)) SWIG_fail;
10975     }
10976     {
10977         PyThreadState* __tstate = wxPyBeginAllowThreads();
10978         result = (long)((wxTextCtrl const *)arg1)->XYToPosition(arg2,arg3);
10979
10980         wxPyEndAllowThreads(__tstate);
10981         if (PyErr_Occurred()) SWIG_fail;
10982     }
10983     {
10984         resultobj = SWIG_From_long((long)(result));
10985     }
10986     return resultobj;
10987     fail:
10988     return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_TextCtrl_PositionToXY(PyObject *, PyObject *args, PyObject *kwargs) {
10993     PyObject *resultobj;
10994     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10995     long arg2 ;
10996     long *arg3 = (long *) 0 ;
10997     long *arg4 = (long *) 0 ;
10998     long temp3 ;
10999     int res3 = 0 ;
11000     long temp4 ;
11001     int res4 = 0 ;
11002     PyObject * obj0 = 0 ;
11003     PyObject * obj1 = 0 ;
11004     char *kwnames[] = {
11005         (char *) "self",(char *) "pos", NULL
11006     };
11007
11008     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11009     arg4 = &temp4; res4 = SWIG_NEWOBJ;
11010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_PositionToXY",kwnames,&obj0,&obj1)) goto fail;
11011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11012     if (SWIG_arg_fail(1)) SWIG_fail;
11013     {
11014         arg2 = (long)(SWIG_As_long(obj1));
11015         if (SWIG_arg_fail(2)) SWIG_fail;
11016     }
11017     {
11018         PyThreadState* __tstate = wxPyBeginAllowThreads();
11019         ((wxTextCtrl const *)arg1)->PositionToXY(arg2,arg3,arg4);
11020
11021         wxPyEndAllowThreads(__tstate);
11022         if (PyErr_Occurred()) SWIG_fail;
11023     }
11024     Py_INCREF(Py_None); resultobj = Py_None;
11025     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11026     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11027     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11028     SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
11029     return resultobj;
11030     fail:
11031     return NULL;
11032 }
11033
11034
11035 static PyObject *_wrap_TextCtrl_ShowPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11036     PyObject *resultobj;
11037     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11038     long arg2 ;
11039     PyObject * obj0 = 0 ;
11040     PyObject * obj1 = 0 ;
11041     char *kwnames[] = {
11042         (char *) "self",(char *) "pos", NULL
11043     };
11044
11045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_ShowPosition",kwnames,&obj0,&obj1)) goto fail;
11046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11047     if (SWIG_arg_fail(1)) SWIG_fail;
11048     {
11049         arg2 = (long)(SWIG_As_long(obj1));
11050         if (SWIG_arg_fail(2)) SWIG_fail;
11051     }
11052     {
11053         PyThreadState* __tstate = wxPyBeginAllowThreads();
11054         (arg1)->ShowPosition(arg2);
11055
11056         wxPyEndAllowThreads(__tstate);
11057         if (PyErr_Occurred()) SWIG_fail;
11058     }
11059     Py_INCREF(Py_None); resultobj = Py_None;
11060     return resultobj;
11061     fail:
11062     return NULL;
11063 }
11064
11065
11066 static PyObject *_wrap_TextCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11067     PyObject *resultobj;
11068     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11069     wxPoint *arg2 = 0 ;
11070     long *arg3 = (long *) 0 ;
11071     long *arg4 = (long *) 0 ;
11072     wxTextCtrlHitTestResult result;
11073     wxPoint temp2 ;
11074     long temp3 ;
11075     int res3 = 0 ;
11076     long temp4 ;
11077     int res4 = 0 ;
11078     PyObject * obj0 = 0 ;
11079     PyObject * obj1 = 0 ;
11080     char *kwnames[] = {
11081         (char *) "self",(char *) "pt", NULL
11082     };
11083
11084     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11085     arg4 = &temp4; res4 = SWIG_NEWOBJ;
11086     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
11087     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11088     if (SWIG_arg_fail(1)) SWIG_fail;
11089     {
11090         arg2 = &temp2;
11091         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11092     }
11093     {
11094         PyThreadState* __tstate = wxPyBeginAllowThreads();
11095         result = (wxTextCtrlHitTestResult)((wxTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3,arg4);
11096
11097         wxPyEndAllowThreads(__tstate);
11098         if (PyErr_Occurred()) SWIG_fail;
11099     }
11100     resultobj = SWIG_From_int((result));
11101     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11102     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11103     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11104     SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
11105     return resultobj;
11106     fail:
11107     return NULL;
11108 }
11109
11110
11111 static PyObject *_wrap_TextCtrl_HitTestPos(PyObject *, PyObject *args, PyObject *kwargs) {
11112     PyObject *resultobj;
11113     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11114     wxPoint *arg2 = 0 ;
11115     long *arg3 = (long *) 0 ;
11116     wxTextCtrlHitTestResult result;
11117     wxPoint temp2 ;
11118     long temp3 ;
11119     int res3 = 0 ;
11120     PyObject * obj0 = 0 ;
11121     PyObject * obj1 = 0 ;
11122     char *kwnames[] = {
11123         (char *) "self",(char *) "pt", NULL
11124     };
11125
11126     arg3 = &temp3; res3 = SWIG_NEWOBJ;
11127     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_HitTestPos",kwnames,&obj0,&obj1)) goto fail;
11128     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11129     if (SWIG_arg_fail(1)) SWIG_fail;
11130     {
11131         arg2 = &temp2;
11132         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11133     }
11134     {
11135         PyThreadState* __tstate = wxPyBeginAllowThreads();
11136         result = (wxTextCtrlHitTestResult)((wxTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3);
11137
11138         wxPyEndAllowThreads(__tstate);
11139         if (PyErr_Occurred()) SWIG_fail;
11140     }
11141     resultobj = SWIG_From_int((result));
11142     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11143     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
11144     return resultobj;
11145     fail:
11146     return NULL;
11147 }
11148
11149
11150 static PyObject *_wrap_TextCtrl_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
11151     PyObject *resultobj;
11152     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11153     PyObject * obj0 = 0 ;
11154     char *kwnames[] = {
11155         (char *) "self", NULL
11156     };
11157
11158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Copy",kwnames,&obj0)) goto fail;
11159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11160     if (SWIG_arg_fail(1)) SWIG_fail;
11161     {
11162         PyThreadState* __tstate = wxPyBeginAllowThreads();
11163         (arg1)->Copy();
11164
11165         wxPyEndAllowThreads(__tstate);
11166         if (PyErr_Occurred()) SWIG_fail;
11167     }
11168     Py_INCREF(Py_None); resultobj = Py_None;
11169     return resultobj;
11170     fail:
11171     return NULL;
11172 }
11173
11174
11175 static PyObject *_wrap_TextCtrl_Cut(PyObject *, PyObject *args, PyObject *kwargs) {
11176     PyObject *resultobj;
11177     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11178     PyObject * obj0 = 0 ;
11179     char *kwnames[] = {
11180         (char *) "self", NULL
11181     };
11182
11183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Cut",kwnames,&obj0)) goto fail;
11184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11185     if (SWIG_arg_fail(1)) SWIG_fail;
11186     {
11187         PyThreadState* __tstate = wxPyBeginAllowThreads();
11188         (arg1)->Cut();
11189
11190         wxPyEndAllowThreads(__tstate);
11191         if (PyErr_Occurred()) SWIG_fail;
11192     }
11193     Py_INCREF(Py_None); resultobj = Py_None;
11194     return resultobj;
11195     fail:
11196     return NULL;
11197 }
11198
11199
11200 static PyObject *_wrap_TextCtrl_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
11201     PyObject *resultobj;
11202     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11203     PyObject * obj0 = 0 ;
11204     char *kwnames[] = {
11205         (char *) "self", NULL
11206     };
11207
11208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Paste",kwnames,&obj0)) goto fail;
11209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11210     if (SWIG_arg_fail(1)) SWIG_fail;
11211     {
11212         PyThreadState* __tstate = wxPyBeginAllowThreads();
11213         (arg1)->Paste();
11214
11215         wxPyEndAllowThreads(__tstate);
11216         if (PyErr_Occurred()) SWIG_fail;
11217     }
11218     Py_INCREF(Py_None); resultobj = Py_None;
11219     return resultobj;
11220     fail:
11221     return NULL;
11222 }
11223
11224
11225 static PyObject *_wrap_TextCtrl_CanCopy(PyObject *, PyObject *args, PyObject *kwargs) {
11226     PyObject *resultobj;
11227     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11228     bool result;
11229     PyObject * obj0 = 0 ;
11230     char *kwnames[] = {
11231         (char *) "self", NULL
11232     };
11233
11234     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanCopy",kwnames,&obj0)) goto fail;
11235     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11236     if (SWIG_arg_fail(1)) SWIG_fail;
11237     {
11238         PyThreadState* __tstate = wxPyBeginAllowThreads();
11239         result = (bool)((wxTextCtrl const *)arg1)->CanCopy();
11240
11241         wxPyEndAllowThreads(__tstate);
11242         if (PyErr_Occurred()) SWIG_fail;
11243     }
11244     {
11245         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11246     }
11247     return resultobj;
11248     fail:
11249     return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_TextCtrl_CanCut(PyObject *, PyObject *args, PyObject *kwargs) {
11254     PyObject *resultobj;
11255     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11256     bool result;
11257     PyObject * obj0 = 0 ;
11258     char *kwnames[] = {
11259         (char *) "self", NULL
11260     };
11261
11262     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanCut",kwnames,&obj0)) goto fail;
11263     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11264     if (SWIG_arg_fail(1)) SWIG_fail;
11265     {
11266         PyThreadState* __tstate = wxPyBeginAllowThreads();
11267         result = (bool)((wxTextCtrl const *)arg1)->CanCut();
11268
11269         wxPyEndAllowThreads(__tstate);
11270         if (PyErr_Occurred()) SWIG_fail;
11271     }
11272     {
11273         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11274     }
11275     return resultobj;
11276     fail:
11277     return NULL;
11278 }
11279
11280
11281 static PyObject *_wrap_TextCtrl_CanPaste(PyObject *, PyObject *args, PyObject *kwargs) {
11282     PyObject *resultobj;
11283     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11284     bool result;
11285     PyObject * obj0 = 0 ;
11286     char *kwnames[] = {
11287         (char *) "self", NULL
11288     };
11289
11290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanPaste",kwnames,&obj0)) goto fail;
11291     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11292     if (SWIG_arg_fail(1)) SWIG_fail;
11293     {
11294         PyThreadState* __tstate = wxPyBeginAllowThreads();
11295         result = (bool)((wxTextCtrl const *)arg1)->CanPaste();
11296
11297         wxPyEndAllowThreads(__tstate);
11298         if (PyErr_Occurred()) SWIG_fail;
11299     }
11300     {
11301         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11302     }
11303     return resultobj;
11304     fail:
11305     return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_TextCtrl_Undo(PyObject *, PyObject *args, PyObject *kwargs) {
11310     PyObject *resultobj;
11311     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11312     PyObject * obj0 = 0 ;
11313     char *kwnames[] = {
11314         (char *) "self", NULL
11315     };
11316
11317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Undo",kwnames,&obj0)) goto fail;
11318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11319     if (SWIG_arg_fail(1)) SWIG_fail;
11320     {
11321         PyThreadState* __tstate = wxPyBeginAllowThreads();
11322         (arg1)->Undo();
11323
11324         wxPyEndAllowThreads(__tstate);
11325         if (PyErr_Occurred()) SWIG_fail;
11326     }
11327     Py_INCREF(Py_None); resultobj = Py_None;
11328     return resultobj;
11329     fail:
11330     return NULL;
11331 }
11332
11333
11334 static PyObject *_wrap_TextCtrl_Redo(PyObject *, PyObject *args, PyObject *kwargs) {
11335     PyObject *resultobj;
11336     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11337     PyObject * obj0 = 0 ;
11338     char *kwnames[] = {
11339         (char *) "self", NULL
11340     };
11341
11342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_Redo",kwnames,&obj0)) goto fail;
11343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11344     if (SWIG_arg_fail(1)) SWIG_fail;
11345     {
11346         PyThreadState* __tstate = wxPyBeginAllowThreads();
11347         (arg1)->Redo();
11348
11349         wxPyEndAllowThreads(__tstate);
11350         if (PyErr_Occurred()) SWIG_fail;
11351     }
11352     Py_INCREF(Py_None); resultobj = Py_None;
11353     return resultobj;
11354     fail:
11355     return NULL;
11356 }
11357
11358
11359 static PyObject *_wrap_TextCtrl_CanUndo(PyObject *, PyObject *args, PyObject *kwargs) {
11360     PyObject *resultobj;
11361     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11362     bool result;
11363     PyObject * obj0 = 0 ;
11364     char *kwnames[] = {
11365         (char *) "self", NULL
11366     };
11367
11368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanUndo",kwnames,&obj0)) goto fail;
11369     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11370     if (SWIG_arg_fail(1)) SWIG_fail;
11371     {
11372         PyThreadState* __tstate = wxPyBeginAllowThreads();
11373         result = (bool)((wxTextCtrl const *)arg1)->CanUndo();
11374
11375         wxPyEndAllowThreads(__tstate);
11376         if (PyErr_Occurred()) SWIG_fail;
11377     }
11378     {
11379         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11380     }
11381     return resultobj;
11382     fail:
11383     return NULL;
11384 }
11385
11386
11387 static PyObject *_wrap_TextCtrl_CanRedo(PyObject *, PyObject *args, PyObject *kwargs) {
11388     PyObject *resultobj;
11389     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11390     bool result;
11391     PyObject * obj0 = 0 ;
11392     char *kwnames[] = {
11393         (char *) "self", NULL
11394     };
11395
11396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_CanRedo",kwnames,&obj0)) goto fail;
11397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11398     if (SWIG_arg_fail(1)) SWIG_fail;
11399     {
11400         PyThreadState* __tstate = wxPyBeginAllowThreads();
11401         result = (bool)((wxTextCtrl const *)arg1)->CanRedo();
11402
11403         wxPyEndAllowThreads(__tstate);
11404         if (PyErr_Occurred()) SWIG_fail;
11405     }
11406     {
11407         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11408     }
11409     return resultobj;
11410     fail:
11411     return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_TextCtrl_SetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
11416     PyObject *resultobj;
11417     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11418     long arg2 ;
11419     PyObject * obj0 = 0 ;
11420     PyObject * obj1 = 0 ;
11421     char *kwnames[] = {
11422         (char *) "self",(char *) "pos", NULL
11423     };
11424
11425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetInsertionPoint",kwnames,&obj0,&obj1)) goto fail;
11426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11427     if (SWIG_arg_fail(1)) SWIG_fail;
11428     {
11429         arg2 = (long)(SWIG_As_long(obj1));
11430         if (SWIG_arg_fail(2)) SWIG_fail;
11431     }
11432     {
11433         PyThreadState* __tstate = wxPyBeginAllowThreads();
11434         (arg1)->SetInsertionPoint(arg2);
11435
11436         wxPyEndAllowThreads(__tstate);
11437         if (PyErr_Occurred()) SWIG_fail;
11438     }
11439     Py_INCREF(Py_None); resultobj = Py_None;
11440     return resultobj;
11441     fail:
11442     return NULL;
11443 }
11444
11445
11446 static PyObject *_wrap_TextCtrl_SetInsertionPointEnd(PyObject *, PyObject *args, PyObject *kwargs) {
11447     PyObject *resultobj;
11448     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11449     PyObject * obj0 = 0 ;
11450     char *kwnames[] = {
11451         (char *) "self", NULL
11452     };
11453
11454     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_SetInsertionPointEnd",kwnames,&obj0)) goto fail;
11455     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11456     if (SWIG_arg_fail(1)) SWIG_fail;
11457     {
11458         PyThreadState* __tstate = wxPyBeginAllowThreads();
11459         (arg1)->SetInsertionPointEnd();
11460
11461         wxPyEndAllowThreads(__tstate);
11462         if (PyErr_Occurred()) SWIG_fail;
11463     }
11464     Py_INCREF(Py_None); resultobj = Py_None;
11465     return resultobj;
11466     fail:
11467     return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_TextCtrl_GetInsertionPoint(PyObject *, PyObject *args, PyObject *kwargs) {
11472     PyObject *resultobj;
11473     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11474     long result;
11475     PyObject * obj0 = 0 ;
11476     char *kwnames[] = {
11477         (char *) "self", NULL
11478     };
11479
11480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetInsertionPoint",kwnames,&obj0)) goto fail;
11481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11482     if (SWIG_arg_fail(1)) SWIG_fail;
11483     {
11484         PyThreadState* __tstate = wxPyBeginAllowThreads();
11485         result = (long)((wxTextCtrl const *)arg1)->GetInsertionPoint();
11486
11487         wxPyEndAllowThreads(__tstate);
11488         if (PyErr_Occurred()) SWIG_fail;
11489     }
11490     {
11491         resultobj = SWIG_From_long((long)(result));
11492     }
11493     return resultobj;
11494     fail:
11495     return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_TextCtrl_GetLastPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11500     PyObject *resultobj;
11501     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11502     long result;
11503     PyObject * obj0 = 0 ;
11504     char *kwnames[] = {
11505         (char *) "self", NULL
11506     };
11507
11508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_GetLastPosition",kwnames,&obj0)) goto fail;
11509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11510     if (SWIG_arg_fail(1)) SWIG_fail;
11511     {
11512         PyThreadState* __tstate = wxPyBeginAllowThreads();
11513         result = (long)((wxTextCtrl const *)arg1)->GetLastPosition();
11514
11515         wxPyEndAllowThreads(__tstate);
11516         if (PyErr_Occurred()) SWIG_fail;
11517     }
11518     {
11519         resultobj = SWIG_From_long((long)(result));
11520     }
11521     return resultobj;
11522     fail:
11523     return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_TextCtrl_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11528     PyObject *resultobj;
11529     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11530     long arg2 ;
11531     long arg3 ;
11532     PyObject * obj0 = 0 ;
11533     PyObject * obj1 = 0 ;
11534     PyObject * obj2 = 0 ;
11535     char *kwnames[] = {
11536         (char *) "self",(char *) "from",(char *) "to", NULL
11537     };
11538
11539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
11540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11541     if (SWIG_arg_fail(1)) SWIG_fail;
11542     {
11543         arg2 = (long)(SWIG_As_long(obj1));
11544         if (SWIG_arg_fail(2)) SWIG_fail;
11545     }
11546     {
11547         arg3 = (long)(SWIG_As_long(obj2));
11548         if (SWIG_arg_fail(3)) SWIG_fail;
11549     }
11550     {
11551         PyThreadState* __tstate = wxPyBeginAllowThreads();
11552         (arg1)->SetSelection(arg2,arg3);
11553
11554         wxPyEndAllowThreads(__tstate);
11555         if (PyErr_Occurred()) SWIG_fail;
11556     }
11557     Py_INCREF(Py_None); resultobj = Py_None;
11558     return resultobj;
11559     fail:
11560     return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_TextCtrl_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
11565     PyObject *resultobj;
11566     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11567     PyObject * obj0 = 0 ;
11568     char *kwnames[] = {
11569         (char *) "self", NULL
11570     };
11571
11572     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_SelectAll",kwnames,&obj0)) goto fail;
11573     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11574     if (SWIG_arg_fail(1)) SWIG_fail;
11575     {
11576         PyThreadState* __tstate = wxPyBeginAllowThreads();
11577         (arg1)->SelectAll();
11578
11579         wxPyEndAllowThreads(__tstate);
11580         if (PyErr_Occurred()) SWIG_fail;
11581     }
11582     Py_INCREF(Py_None); resultobj = Py_None;
11583     return resultobj;
11584     fail:
11585     return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_TextCtrl_SetEditable(PyObject *, PyObject *args, PyObject *kwargs) {
11590     PyObject *resultobj;
11591     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11592     bool arg2 ;
11593     PyObject * obj0 = 0 ;
11594     PyObject * obj1 = 0 ;
11595     char *kwnames[] = {
11596         (char *) "self",(char *) "editable", NULL
11597     };
11598
11599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_SetEditable",kwnames,&obj0,&obj1)) goto fail;
11600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11601     if (SWIG_arg_fail(1)) SWIG_fail;
11602     {
11603         arg2 = (bool)(SWIG_As_bool(obj1));
11604         if (SWIG_arg_fail(2)) SWIG_fail;
11605     }
11606     {
11607         PyThreadState* __tstate = wxPyBeginAllowThreads();
11608         (arg1)->SetEditable(arg2);
11609
11610         wxPyEndAllowThreads(__tstate);
11611         if (PyErr_Occurred()) SWIG_fail;
11612     }
11613     Py_INCREF(Py_None); resultobj = Py_None;
11614     return resultobj;
11615     fail:
11616     return NULL;
11617 }
11618
11619
11620 static PyObject *_wrap_TextCtrl_ShowNativeCaret(PyObject *, PyObject *args, PyObject *kwargs) {
11621     PyObject *resultobj;
11622     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11623     bool arg2 = (bool) true ;
11624     bool result;
11625     PyObject * obj0 = 0 ;
11626     PyObject * obj1 = 0 ;
11627     char *kwnames[] = {
11628         (char *) "self",(char *) "show", NULL
11629     };
11630
11631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TextCtrl_ShowNativeCaret",kwnames,&obj0,&obj1)) goto fail;
11632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11633     if (SWIG_arg_fail(1)) SWIG_fail;
11634     if (obj1) {
11635         {
11636             arg2 = (bool)(SWIG_As_bool(obj1));
11637             if (SWIG_arg_fail(2)) SWIG_fail;
11638         }
11639     }
11640     {
11641         PyThreadState* __tstate = wxPyBeginAllowThreads();
11642         result = (bool)(arg1)->ShowNativeCaret(arg2);
11643
11644         wxPyEndAllowThreads(__tstate);
11645         if (PyErr_Occurred()) SWIG_fail;
11646     }
11647     {
11648         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11649     }
11650     return resultobj;
11651     fail:
11652     return NULL;
11653 }
11654
11655
11656 static PyObject *_wrap_TextCtrl_HideNativeCaret(PyObject *, PyObject *args, PyObject *kwargs) {
11657     PyObject *resultobj;
11658     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11659     bool result;
11660     PyObject * obj0 = 0 ;
11661     char *kwnames[] = {
11662         (char *) "self", NULL
11663     };
11664
11665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextCtrl_HideNativeCaret",kwnames,&obj0)) goto fail;
11666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11667     if (SWIG_arg_fail(1)) SWIG_fail;
11668     {
11669         PyThreadState* __tstate = wxPyBeginAllowThreads();
11670         result = (bool)(arg1)->HideNativeCaret();
11671
11672         wxPyEndAllowThreads(__tstate);
11673         if (PyErr_Occurred()) SWIG_fail;
11674     }
11675     {
11676         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677     }
11678     return resultobj;
11679     fail:
11680     return NULL;
11681 }
11682
11683
11684 static PyObject *_wrap_TextCtrl_write(PyObject *, PyObject *args, PyObject *kwargs) {
11685     PyObject *resultobj;
11686     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11687     wxString *arg2 = 0 ;
11688     bool temp2 = false ;
11689     PyObject * obj0 = 0 ;
11690     PyObject * obj1 = 0 ;
11691     char *kwnames[] = {
11692         (char *) "self",(char *) "text", NULL
11693     };
11694
11695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_write",kwnames,&obj0,&obj1)) goto fail;
11696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11697     if (SWIG_arg_fail(1)) SWIG_fail;
11698     {
11699         arg2 = wxString_in_helper(obj1);
11700         if (arg2 == NULL) SWIG_fail;
11701         temp2 = true;
11702     }
11703     {
11704         PyThreadState* __tstate = wxPyBeginAllowThreads();
11705         wxTextCtrl_write(arg1,(wxString const &)*arg2);
11706
11707         wxPyEndAllowThreads(__tstate);
11708         if (PyErr_Occurred()) SWIG_fail;
11709     }
11710     Py_INCREF(Py_None); resultobj = Py_None;
11711     {
11712         if (temp2)
11713         delete arg2;
11714     }
11715     return resultobj;
11716     fail:
11717     {
11718         if (temp2)
11719         delete arg2;
11720     }
11721     return NULL;
11722 }
11723
11724
11725 static PyObject *_wrap_TextCtrl_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11726     PyObject *resultobj;
11727     wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11728     long arg2 ;
11729     long arg3 ;
11730     wxString result;
11731     PyObject * obj0 = 0 ;
11732     PyObject * obj1 = 0 ;
11733     PyObject * obj2 = 0 ;
11734     char *kwnames[] = {
11735         (char *) "self",(char *) "from",(char *) "to", NULL
11736     };
11737
11738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextCtrl_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11739     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
11740     if (SWIG_arg_fail(1)) SWIG_fail;
11741     {
11742         arg2 = (long)(SWIG_As_long(obj1));
11743         if (SWIG_arg_fail(2)) SWIG_fail;
11744     }
11745     {
11746         arg3 = (long)(SWIG_As_long(obj2));
11747         if (SWIG_arg_fail(3)) SWIG_fail;
11748     }
11749     {
11750         PyThreadState* __tstate = wxPyBeginAllowThreads();
11751         result = wxTextCtrl_GetString(arg1,arg2,arg3);
11752
11753         wxPyEndAllowThreads(__tstate);
11754         if (PyErr_Occurred()) SWIG_fail;
11755     }
11756     {
11757 #if wxUSE_UNICODE
11758         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11759 #else
11760         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11761 #endif
11762     }
11763     return resultobj;
11764     fail:
11765     return NULL;
11766 }
11767
11768
11769 static PyObject *_wrap_TextCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
11770     PyObject *resultobj;
11771     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
11772     wxVisualAttributes result;
11773     PyObject * obj0 = 0 ;
11774     char *kwnames[] = {
11775         (char *) "variant", NULL
11776     };
11777
11778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TextCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
11779     if (obj0) {
11780         {
11781             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
11782             if (SWIG_arg_fail(1)) SWIG_fail;
11783         }
11784     }
11785     {
11786         if (!wxPyCheckForApp()) SWIG_fail;
11787         PyThreadState* __tstate = wxPyBeginAllowThreads();
11788         result = wxTextCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
11789
11790         wxPyEndAllowThreads(__tstate);
11791         if (PyErr_Occurred()) SWIG_fail;
11792     }
11793     {
11794         wxVisualAttributes * resultptr;
11795         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
11796         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
11797     }
11798     return resultobj;
11799     fail:
11800     return NULL;
11801 }
11802
11803
11804 static PyObject * TextCtrl_swigregister(PyObject *, PyObject *args) {
11805     PyObject *obj;
11806     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11807     SWIG_TypeClientData(SWIGTYPE_p_wxTextCtrl, obj);
11808     Py_INCREF(obj);
11809     return Py_BuildValue((char *)"");
11810 }
11811 static PyObject *_wrap_new_TextUrlEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11812     PyObject *resultobj;
11813     int arg1 ;
11814     wxMouseEvent *arg2 = 0 ;
11815     long arg3 ;
11816     long arg4 ;
11817     wxTextUrlEvent *result;
11818     PyObject * obj0 = 0 ;
11819     PyObject * obj1 = 0 ;
11820     PyObject * obj2 = 0 ;
11821     PyObject * obj3 = 0 ;
11822     char *kwnames[] = {
11823         (char *) "winid",(char *) "evtMouse",(char *) "start",(char *) "end", NULL
11824     };
11825
11826     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_TextUrlEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11827     {
11828         arg1 = (int)(SWIG_As_int(obj0));
11829         if (SWIG_arg_fail(1)) SWIG_fail;
11830     }
11831     {
11832         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
11833         if (SWIG_arg_fail(2)) SWIG_fail;
11834         if (arg2 == NULL) {
11835             SWIG_null_ref("wxMouseEvent");
11836         }
11837         if (SWIG_arg_fail(2)) SWIG_fail;
11838     }
11839     {
11840         arg3 = (long)(SWIG_As_long(obj2));
11841         if (SWIG_arg_fail(3)) SWIG_fail;
11842     }
11843     {
11844         arg4 = (long)(SWIG_As_long(obj3));
11845         if (SWIG_arg_fail(4)) SWIG_fail;
11846     }
11847     {
11848         PyThreadState* __tstate = wxPyBeginAllowThreads();
11849         result = (wxTextUrlEvent *)new wxTextUrlEvent(arg1,(wxMouseEvent const &)*arg2,arg3,arg4);
11850
11851         wxPyEndAllowThreads(__tstate);
11852         if (PyErr_Occurred()) SWIG_fail;
11853     }
11854     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextUrlEvent, 1);
11855     return resultobj;
11856     fail:
11857     return NULL;
11858 }
11859
11860
11861 static PyObject *_wrap_TextUrlEvent_GetMouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11862     PyObject *resultobj;
11863     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11864     wxMouseEvent *result;
11865     PyObject * obj0 = 0 ;
11866     char *kwnames[] = {
11867         (char *) "self", NULL
11868     };
11869
11870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetMouseEvent",kwnames,&obj0)) goto fail;
11871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11872     if (SWIG_arg_fail(1)) SWIG_fail;
11873     {
11874         PyThreadState* __tstate = wxPyBeginAllowThreads();
11875         {
11876             wxMouseEvent const &_result_ref = (arg1)->GetMouseEvent();
11877             result = (wxMouseEvent *) &_result_ref;
11878         }
11879
11880         wxPyEndAllowThreads(__tstate);
11881         if (PyErr_Occurred()) SWIG_fail;
11882     }
11883     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseEvent, 0);
11884     return resultobj;
11885     fail:
11886     return NULL;
11887 }
11888
11889
11890 static PyObject *_wrap_TextUrlEvent_GetURLStart(PyObject *, PyObject *args, PyObject *kwargs) {
11891     PyObject *resultobj;
11892     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11893     long result;
11894     PyObject * obj0 = 0 ;
11895     char *kwnames[] = {
11896         (char *) "self", NULL
11897     };
11898
11899     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetURLStart",kwnames,&obj0)) goto fail;
11900     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11901     if (SWIG_arg_fail(1)) SWIG_fail;
11902     {
11903         PyThreadState* __tstate = wxPyBeginAllowThreads();
11904         result = (long)((wxTextUrlEvent const *)arg1)->GetURLStart();
11905
11906         wxPyEndAllowThreads(__tstate);
11907         if (PyErr_Occurred()) SWIG_fail;
11908     }
11909     {
11910         resultobj = SWIG_From_long((long)(result));
11911     }
11912     return resultobj;
11913     fail:
11914     return NULL;
11915 }
11916
11917
11918 static PyObject *_wrap_TextUrlEvent_GetURLEnd(PyObject *, PyObject *args, PyObject *kwargs) {
11919     PyObject *resultobj;
11920     wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
11921     long result;
11922     PyObject * obj0 = 0 ;
11923     char *kwnames[] = {
11924         (char *) "self", NULL
11925     };
11926
11927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextUrlEvent_GetURLEnd",kwnames,&obj0)) goto fail;
11928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_EXCEPTION | 0);
11929     if (SWIG_arg_fail(1)) SWIG_fail;
11930     {
11931         PyThreadState* __tstate = wxPyBeginAllowThreads();
11932         result = (long)((wxTextUrlEvent const *)arg1)->GetURLEnd();
11933
11934         wxPyEndAllowThreads(__tstate);
11935         if (PyErr_Occurred()) SWIG_fail;
11936     }
11937     {
11938         resultobj = SWIG_From_long((long)(result));
11939     }
11940     return resultobj;
11941     fail:
11942     return NULL;
11943 }
11944
11945
11946 static PyObject * TextUrlEvent_swigregister(PyObject *, PyObject *args) {
11947     PyObject *obj;
11948     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11949     SWIG_TypeClientData(SWIGTYPE_p_wxTextUrlEvent, obj);
11950     Py_INCREF(obj);
11951     return Py_BuildValue((char *)"");
11952 }
11953 static int _wrap_ScrollBarNameStr_set(PyObject *) {
11954     PyErr_SetString(PyExc_TypeError,"Variable ScrollBarNameStr is read-only.");
11955     return 1;
11956 }
11957
11958
11959 static PyObject *_wrap_ScrollBarNameStr_get(void) {
11960     PyObject *pyobj;
11961
11962     {
11963 #if wxUSE_UNICODE
11964         pyobj = PyUnicode_FromWideChar((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
11965 #else
11966         pyobj = PyString_FromStringAndSize((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
11967 #endif
11968     }
11969     return pyobj;
11970 }
11971
11972
11973 static PyObject *_wrap_new_ScrollBar(PyObject *, PyObject *args, PyObject *kwargs) {
11974     PyObject *resultobj;
11975     wxWindow *arg1 = (wxWindow *) 0 ;
11976     int arg2 = (int) -1 ;
11977     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11978     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11979     wxSize const &arg4_defvalue = wxDefaultSize ;
11980     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11981     long arg5 = (long) wxSB_HORIZONTAL ;
11982     wxValidator const &arg6_defvalue = wxDefaultValidator ;
11983     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
11984     wxString const &arg7_defvalue = wxPyScrollBarNameStr ;
11985     wxString *arg7 = (wxString *) &arg7_defvalue ;
11986     wxScrollBar *result;
11987     wxPoint temp3 ;
11988     wxSize temp4 ;
11989     bool temp7 = false ;
11990     PyObject * obj0 = 0 ;
11991     PyObject * obj1 = 0 ;
11992     PyObject * obj2 = 0 ;
11993     PyObject * obj3 = 0 ;
11994     PyObject * obj4 = 0 ;
11995     PyObject * obj5 = 0 ;
11996     PyObject * obj6 = 0 ;
11997     char *kwnames[] = {
11998         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
11999     };
12000
12001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ScrollBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12002     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12003     if (SWIG_arg_fail(1)) SWIG_fail;
12004     if (obj1) {
12005         {
12006             arg2 = (int)(SWIG_As_int(obj1));
12007             if (SWIG_arg_fail(2)) SWIG_fail;
12008         }
12009     }
12010     if (obj2) {
12011         {
12012             arg3 = &temp3;
12013             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12014         }
12015     }
12016     if (obj3) {
12017         {
12018             arg4 = &temp4;
12019             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12020         }
12021     }
12022     if (obj4) {
12023         {
12024             arg5 = (long)(SWIG_As_long(obj4));
12025             if (SWIG_arg_fail(5)) SWIG_fail;
12026         }
12027     }
12028     if (obj5) {
12029         {
12030             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
12031             if (SWIG_arg_fail(6)) SWIG_fail;
12032             if (arg6 == NULL) {
12033                 SWIG_null_ref("wxValidator");
12034             }
12035             if (SWIG_arg_fail(6)) SWIG_fail;
12036         }
12037     }
12038     if (obj6) {
12039         {
12040             arg7 = wxString_in_helper(obj6);
12041             if (arg7 == NULL) SWIG_fail;
12042             temp7 = true;
12043         }
12044     }
12045     {
12046         if (!wxPyCheckForApp()) SWIG_fail;
12047         PyThreadState* __tstate = wxPyBeginAllowThreads();
12048         result = (wxScrollBar *)new wxScrollBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
12049
12050         wxPyEndAllowThreads(__tstate);
12051         if (PyErr_Occurred()) SWIG_fail;
12052     }
12053     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollBar, 1);
12054     {
12055         if (temp7)
12056         delete arg7;
12057     }
12058     return resultobj;
12059     fail:
12060     {
12061         if (temp7)
12062         delete arg7;
12063     }
12064     return NULL;
12065 }
12066
12067
12068 static PyObject *_wrap_new_PreScrollBar(PyObject *, PyObject *args, PyObject *kwargs) {
12069     PyObject *resultobj;
12070     wxScrollBar *result;
12071     char *kwnames[] = {
12072         NULL
12073     };
12074
12075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreScrollBar",kwnames)) goto fail;
12076     {
12077         if (!wxPyCheckForApp()) SWIG_fail;
12078         PyThreadState* __tstate = wxPyBeginAllowThreads();
12079         result = (wxScrollBar *)new wxScrollBar();
12080
12081         wxPyEndAllowThreads(__tstate);
12082         if (PyErr_Occurred()) SWIG_fail;
12083     }
12084     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollBar, 1);
12085     return resultobj;
12086     fail:
12087     return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_ScrollBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12092     PyObject *resultobj;
12093     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12094     wxWindow *arg2 = (wxWindow *) 0 ;
12095     int arg3 = (int) -1 ;
12096     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12097     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12098     wxSize const &arg5_defvalue = wxDefaultSize ;
12099     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12100     long arg6 = (long) wxSB_HORIZONTAL ;
12101     wxValidator const &arg7_defvalue = wxDefaultValidator ;
12102     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
12103     wxString const &arg8_defvalue = wxPyScrollBarNameStr ;
12104     wxString *arg8 = (wxString *) &arg8_defvalue ;
12105     bool result;
12106     wxPoint temp4 ;
12107     wxSize temp5 ;
12108     bool temp8 = false ;
12109     PyObject * obj0 = 0 ;
12110     PyObject * obj1 = 0 ;
12111     PyObject * obj2 = 0 ;
12112     PyObject * obj3 = 0 ;
12113     PyObject * obj4 = 0 ;
12114     PyObject * obj5 = 0 ;
12115     PyObject * obj6 = 0 ;
12116     PyObject * obj7 = 0 ;
12117     char *kwnames[] = {
12118         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
12119     };
12120
12121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ScrollBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
12122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12123     if (SWIG_arg_fail(1)) SWIG_fail;
12124     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12125     if (SWIG_arg_fail(2)) SWIG_fail;
12126     if (obj2) {
12127         {
12128             arg3 = (int)(SWIG_As_int(obj2));
12129             if (SWIG_arg_fail(3)) SWIG_fail;
12130         }
12131     }
12132     if (obj3) {
12133         {
12134             arg4 = &temp4;
12135             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12136         }
12137     }
12138     if (obj4) {
12139         {
12140             arg5 = &temp5;
12141             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12142         }
12143     }
12144     if (obj5) {
12145         {
12146             arg6 = (long)(SWIG_As_long(obj5));
12147             if (SWIG_arg_fail(6)) SWIG_fail;
12148         }
12149     }
12150     if (obj6) {
12151         {
12152             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
12153             if (SWIG_arg_fail(7)) SWIG_fail;
12154             if (arg7 == NULL) {
12155                 SWIG_null_ref("wxValidator");
12156             }
12157             if (SWIG_arg_fail(7)) SWIG_fail;
12158         }
12159     }
12160     if (obj7) {
12161         {
12162             arg8 = wxString_in_helper(obj7);
12163             if (arg8 == NULL) SWIG_fail;
12164             temp8 = true;
12165         }
12166     }
12167     {
12168         PyThreadState* __tstate = wxPyBeginAllowThreads();
12169         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
12170
12171         wxPyEndAllowThreads(__tstate);
12172         if (PyErr_Occurred()) SWIG_fail;
12173     }
12174     {
12175         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12176     }
12177     {
12178         if (temp8)
12179         delete arg8;
12180     }
12181     return resultobj;
12182     fail:
12183     {
12184         if (temp8)
12185         delete arg8;
12186     }
12187     return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_ScrollBar_GetThumbPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12192     PyObject *resultobj;
12193     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12194     int result;
12195     PyObject * obj0 = 0 ;
12196     char *kwnames[] = {
12197         (char *) "self", NULL
12198     };
12199
12200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetThumbPosition",kwnames,&obj0)) goto fail;
12201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12202     if (SWIG_arg_fail(1)) SWIG_fail;
12203     {
12204         PyThreadState* __tstate = wxPyBeginAllowThreads();
12205         result = (int)((wxScrollBar const *)arg1)->GetThumbPosition();
12206
12207         wxPyEndAllowThreads(__tstate);
12208         if (PyErr_Occurred()) SWIG_fail;
12209     }
12210     {
12211         resultobj = SWIG_From_int((int)(result));
12212     }
12213     return resultobj;
12214     fail:
12215     return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_ScrollBar_GetThumbSize(PyObject *, PyObject *args, PyObject *kwargs) {
12220     PyObject *resultobj;
12221     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12222     int result;
12223     PyObject * obj0 = 0 ;
12224     char *kwnames[] = {
12225         (char *) "self", NULL
12226     };
12227
12228     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetThumbSize",kwnames,&obj0)) goto fail;
12229     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12230     if (SWIG_arg_fail(1)) SWIG_fail;
12231     {
12232         PyThreadState* __tstate = wxPyBeginAllowThreads();
12233         result = (int)((wxScrollBar const *)arg1)->GetThumbSize();
12234
12235         wxPyEndAllowThreads(__tstate);
12236         if (PyErr_Occurred()) SWIG_fail;
12237     }
12238     {
12239         resultobj = SWIG_From_int((int)(result));
12240     }
12241     return resultobj;
12242     fail:
12243     return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_ScrollBar_GetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
12248     PyObject *resultobj;
12249     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12250     int result;
12251     PyObject * obj0 = 0 ;
12252     char *kwnames[] = {
12253         (char *) "self", NULL
12254     };
12255
12256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetPageSize",kwnames,&obj0)) goto fail;
12257     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12258     if (SWIG_arg_fail(1)) SWIG_fail;
12259     {
12260         PyThreadState* __tstate = wxPyBeginAllowThreads();
12261         result = (int)((wxScrollBar const *)arg1)->GetPageSize();
12262
12263         wxPyEndAllowThreads(__tstate);
12264         if (PyErr_Occurred()) SWIG_fail;
12265     }
12266     {
12267         resultobj = SWIG_From_int((int)(result));
12268     }
12269     return resultobj;
12270     fail:
12271     return NULL;
12272 }
12273
12274
12275 static PyObject *_wrap_ScrollBar_GetRange(PyObject *, PyObject *args, PyObject *kwargs) {
12276     PyObject *resultobj;
12277     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12278     int result;
12279     PyObject * obj0 = 0 ;
12280     char *kwnames[] = {
12281         (char *) "self", NULL
12282     };
12283
12284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_GetRange",kwnames,&obj0)) goto fail;
12285     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12286     if (SWIG_arg_fail(1)) SWIG_fail;
12287     {
12288         PyThreadState* __tstate = wxPyBeginAllowThreads();
12289         result = (int)((wxScrollBar const *)arg1)->GetRange();
12290
12291         wxPyEndAllowThreads(__tstate);
12292         if (PyErr_Occurred()) SWIG_fail;
12293     }
12294     {
12295         resultobj = SWIG_From_int((int)(result));
12296     }
12297     return resultobj;
12298     fail:
12299     return NULL;
12300 }
12301
12302
12303 static PyObject *_wrap_ScrollBar_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
12304     PyObject *resultobj;
12305     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12306     bool result;
12307     PyObject * obj0 = 0 ;
12308     char *kwnames[] = {
12309         (char *) "self", NULL
12310     };
12311
12312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollBar_IsVertical",kwnames,&obj0)) goto fail;
12313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12314     if (SWIG_arg_fail(1)) SWIG_fail;
12315     {
12316         PyThreadState* __tstate = wxPyBeginAllowThreads();
12317         result = (bool)((wxScrollBar const *)arg1)->IsVertical();
12318
12319         wxPyEndAllowThreads(__tstate);
12320         if (PyErr_Occurred()) SWIG_fail;
12321     }
12322     {
12323         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12324     }
12325     return resultobj;
12326     fail:
12327     return NULL;
12328 }
12329
12330
12331 static PyObject *_wrap_ScrollBar_SetThumbPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12332     PyObject *resultobj;
12333     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12334     int arg2 ;
12335     PyObject * obj0 = 0 ;
12336     PyObject * obj1 = 0 ;
12337     char *kwnames[] = {
12338         (char *) "self",(char *) "viewStart", NULL
12339     };
12340
12341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollBar_SetThumbPosition",kwnames,&obj0,&obj1)) goto fail;
12342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12343     if (SWIG_arg_fail(1)) SWIG_fail;
12344     {
12345         arg2 = (int)(SWIG_As_int(obj1));
12346         if (SWIG_arg_fail(2)) SWIG_fail;
12347     }
12348     {
12349         PyThreadState* __tstate = wxPyBeginAllowThreads();
12350         (arg1)->SetThumbPosition(arg2);
12351
12352         wxPyEndAllowThreads(__tstate);
12353         if (PyErr_Occurred()) SWIG_fail;
12354     }
12355     Py_INCREF(Py_None); resultobj = Py_None;
12356     return resultobj;
12357     fail:
12358     return NULL;
12359 }
12360
12361
12362 static PyObject *_wrap_ScrollBar_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
12363     PyObject *resultobj;
12364     wxScrollBar *arg1 = (wxScrollBar *) 0 ;
12365     int arg2 ;
12366     int arg3 ;
12367     int arg4 ;
12368     int arg5 ;
12369     bool arg6 = (bool) true ;
12370     PyObject * obj0 = 0 ;
12371     PyObject * obj1 = 0 ;
12372     PyObject * obj2 = 0 ;
12373     PyObject * obj3 = 0 ;
12374     PyObject * obj4 = 0 ;
12375     PyObject * obj5 = 0 ;
12376     char *kwnames[] = {
12377         (char *) "self",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "pageSize",(char *) "refresh", NULL
12378     };
12379
12380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:ScrollBar_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12381     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollBar, SWIG_POINTER_EXCEPTION | 0);
12382     if (SWIG_arg_fail(1)) SWIG_fail;
12383     {
12384         arg2 = (int)(SWIG_As_int(obj1));
12385         if (SWIG_arg_fail(2)) SWIG_fail;
12386     }
12387     {
12388         arg3 = (int)(SWIG_As_int(obj2));
12389         if (SWIG_arg_fail(3)) SWIG_fail;
12390     }
12391     {
12392         arg4 = (int)(SWIG_As_int(obj3));
12393         if (SWIG_arg_fail(4)) SWIG_fail;
12394     }
12395     {
12396         arg5 = (int)(SWIG_As_int(obj4));
12397         if (SWIG_arg_fail(5)) SWIG_fail;
12398     }
12399     if (obj5) {
12400         {
12401             arg6 = (bool)(SWIG_As_bool(obj5));
12402             if (SWIG_arg_fail(6)) SWIG_fail;
12403         }
12404     }
12405     {
12406         PyThreadState* __tstate = wxPyBeginAllowThreads();
12407         (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
12408
12409         wxPyEndAllowThreads(__tstate);
12410         if (PyErr_Occurred()) SWIG_fail;
12411     }
12412     Py_INCREF(Py_None); resultobj = Py_None;
12413     return resultobj;
12414     fail:
12415     return NULL;
12416 }
12417
12418
12419 static PyObject *_wrap_ScrollBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
12420     PyObject *resultobj;
12421     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
12422     wxVisualAttributes result;
12423     PyObject * obj0 = 0 ;
12424     char *kwnames[] = {
12425         (char *) "variant", NULL
12426     };
12427
12428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrollBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
12429     if (obj0) {
12430         {
12431             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
12432             if (SWIG_arg_fail(1)) SWIG_fail;
12433         }
12434     }
12435     {
12436         if (!wxPyCheckForApp()) SWIG_fail;
12437         PyThreadState* __tstate = wxPyBeginAllowThreads();
12438         result = wxScrollBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
12439
12440         wxPyEndAllowThreads(__tstate);
12441         if (PyErr_Occurred()) SWIG_fail;
12442     }
12443     {
12444         wxVisualAttributes * resultptr;
12445         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
12446         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
12447     }
12448     return resultobj;
12449     fail:
12450     return NULL;
12451 }
12452
12453
12454 static PyObject * ScrollBar_swigregister(PyObject *, PyObject *args) {
12455     PyObject *obj;
12456     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12457     SWIG_TypeClientData(SWIGTYPE_p_wxScrollBar, obj);
12458     Py_INCREF(obj);
12459     return Py_BuildValue((char *)"");
12460 }
12461 static int _wrap_SPIN_BUTTON_NAME_set(PyObject *) {
12462     PyErr_SetString(PyExc_TypeError,"Variable SPIN_BUTTON_NAME is read-only.");
12463     return 1;
12464 }
12465
12466
12467 static PyObject *_wrap_SPIN_BUTTON_NAME_get(void) {
12468     PyObject *pyobj;
12469
12470     {
12471 #if wxUSE_UNICODE
12472         pyobj = PyUnicode_FromWideChar((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
12473 #else
12474         pyobj = PyString_FromStringAndSize((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
12475 #endif
12476     }
12477     return pyobj;
12478 }
12479
12480
12481 static int _wrap_SpinCtrlNameStr_set(PyObject *) {
12482     PyErr_SetString(PyExc_TypeError,"Variable SpinCtrlNameStr is read-only.");
12483     return 1;
12484 }
12485
12486
12487 static PyObject *_wrap_SpinCtrlNameStr_get(void) {
12488     PyObject *pyobj;
12489
12490     {
12491 #if wxUSE_UNICODE
12492         pyobj = PyUnicode_FromWideChar((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
12493 #else
12494         pyobj = PyString_FromStringAndSize((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
12495 #endif
12496     }
12497     return pyobj;
12498 }
12499
12500
12501 static PyObject *_wrap_new_SpinButton(PyObject *, PyObject *args, PyObject *kwargs) {
12502     PyObject *resultobj;
12503     wxWindow *arg1 = (wxWindow *) 0 ;
12504     int arg2 = (int) -1 ;
12505     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12506     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12507     wxSize const &arg4_defvalue = wxDefaultSize ;
12508     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12509     long arg5 = (long) wxSP_HORIZONTAL ;
12510     wxString const &arg6_defvalue = wxPySPIN_BUTTON_NAME ;
12511     wxString *arg6 = (wxString *) &arg6_defvalue ;
12512     wxSpinButton *result;
12513     wxPoint temp3 ;
12514     wxSize temp4 ;
12515     bool temp6 = false ;
12516     PyObject * obj0 = 0 ;
12517     PyObject * obj1 = 0 ;
12518     PyObject * obj2 = 0 ;
12519     PyObject * obj3 = 0 ;
12520     PyObject * obj4 = 0 ;
12521     PyObject * obj5 = 0 ;
12522     char *kwnames[] = {
12523         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12524     };
12525
12526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SpinButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12528     if (SWIG_arg_fail(1)) SWIG_fail;
12529     if (obj1) {
12530         {
12531             arg2 = (int)(SWIG_As_int(obj1));
12532             if (SWIG_arg_fail(2)) SWIG_fail;
12533         }
12534     }
12535     if (obj2) {
12536         {
12537             arg3 = &temp3;
12538             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12539         }
12540     }
12541     if (obj3) {
12542         {
12543             arg4 = &temp4;
12544             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12545         }
12546     }
12547     if (obj4) {
12548         {
12549             arg5 = (long)(SWIG_As_long(obj4));
12550             if (SWIG_arg_fail(5)) SWIG_fail;
12551         }
12552     }
12553     if (obj5) {
12554         {
12555             arg6 = wxString_in_helper(obj5);
12556             if (arg6 == NULL) SWIG_fail;
12557             temp6 = true;
12558         }
12559     }
12560     {
12561         if (!wxPyCheckForApp()) SWIG_fail;
12562         PyThreadState* __tstate = wxPyBeginAllowThreads();
12563         result = (wxSpinButton *)new wxSpinButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12564
12565         wxPyEndAllowThreads(__tstate);
12566         if (PyErr_Occurred()) SWIG_fail;
12567     }
12568     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinButton, 1);
12569     {
12570         if (temp6)
12571         delete arg6;
12572     }
12573     return resultobj;
12574     fail:
12575     {
12576         if (temp6)
12577         delete arg6;
12578     }
12579     return NULL;
12580 }
12581
12582
12583 static PyObject *_wrap_new_PreSpinButton(PyObject *, PyObject *args, PyObject *kwargs) {
12584     PyObject *resultobj;
12585     wxSpinButton *result;
12586     char *kwnames[] = {
12587         NULL
12588     };
12589
12590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSpinButton",kwnames)) goto fail;
12591     {
12592         if (!wxPyCheckForApp()) SWIG_fail;
12593         PyThreadState* __tstate = wxPyBeginAllowThreads();
12594         result = (wxSpinButton *)new wxSpinButton();
12595
12596         wxPyEndAllowThreads(__tstate);
12597         if (PyErr_Occurred()) SWIG_fail;
12598     }
12599     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinButton, 1);
12600     return resultobj;
12601     fail:
12602     return NULL;
12603 }
12604
12605
12606 static PyObject *_wrap_SpinButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12607     PyObject *resultobj;
12608     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12609     wxWindow *arg2 = (wxWindow *) 0 ;
12610     int arg3 = (int) -1 ;
12611     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12612     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12613     wxSize const &arg5_defvalue = wxDefaultSize ;
12614     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12615     long arg6 = (long) wxSP_HORIZONTAL ;
12616     wxString const &arg7_defvalue = wxPySPIN_BUTTON_NAME ;
12617     wxString *arg7 = (wxString *) &arg7_defvalue ;
12618     bool result;
12619     wxPoint temp4 ;
12620     wxSize temp5 ;
12621     bool temp7 = false ;
12622     PyObject * obj0 = 0 ;
12623     PyObject * obj1 = 0 ;
12624     PyObject * obj2 = 0 ;
12625     PyObject * obj3 = 0 ;
12626     PyObject * obj4 = 0 ;
12627     PyObject * obj5 = 0 ;
12628     PyObject * obj6 = 0 ;
12629     char *kwnames[] = {
12630         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12631     };
12632
12633     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SpinButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12634     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12635     if (SWIG_arg_fail(1)) SWIG_fail;
12636     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12637     if (SWIG_arg_fail(2)) SWIG_fail;
12638     if (obj2) {
12639         {
12640             arg3 = (int)(SWIG_As_int(obj2));
12641             if (SWIG_arg_fail(3)) SWIG_fail;
12642         }
12643     }
12644     if (obj3) {
12645         {
12646             arg4 = &temp4;
12647             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12648         }
12649     }
12650     if (obj4) {
12651         {
12652             arg5 = &temp5;
12653             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12654         }
12655     }
12656     if (obj5) {
12657         {
12658             arg6 = (long)(SWIG_As_long(obj5));
12659             if (SWIG_arg_fail(6)) SWIG_fail;
12660         }
12661     }
12662     if (obj6) {
12663         {
12664             arg7 = wxString_in_helper(obj6);
12665             if (arg7 == NULL) SWIG_fail;
12666             temp7 = true;
12667         }
12668     }
12669     {
12670         PyThreadState* __tstate = wxPyBeginAllowThreads();
12671         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12672
12673         wxPyEndAllowThreads(__tstate);
12674         if (PyErr_Occurred()) SWIG_fail;
12675     }
12676     {
12677         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12678     }
12679     {
12680         if (temp7)
12681         delete arg7;
12682     }
12683     return resultobj;
12684     fail:
12685     {
12686         if (temp7)
12687         delete arg7;
12688     }
12689     return NULL;
12690 }
12691
12692
12693 static PyObject *_wrap_SpinButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
12694     PyObject *resultobj;
12695     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12696     int result;
12697     PyObject * obj0 = 0 ;
12698     char *kwnames[] = {
12699         (char *) "self", NULL
12700     };
12701
12702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetValue",kwnames,&obj0)) goto fail;
12703     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12704     if (SWIG_arg_fail(1)) SWIG_fail;
12705     {
12706         PyThreadState* __tstate = wxPyBeginAllowThreads();
12707         result = (int)((wxSpinButton const *)arg1)->GetValue();
12708
12709         wxPyEndAllowThreads(__tstate);
12710         if (PyErr_Occurred()) SWIG_fail;
12711     }
12712     {
12713         resultobj = SWIG_From_int((int)(result));
12714     }
12715     return resultobj;
12716     fail:
12717     return NULL;
12718 }
12719
12720
12721 static PyObject *_wrap_SpinButton_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
12722     PyObject *resultobj;
12723     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12724     int result;
12725     PyObject * obj0 = 0 ;
12726     char *kwnames[] = {
12727         (char *) "self", NULL
12728     };
12729
12730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetMin",kwnames,&obj0)) goto fail;
12731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12732     if (SWIG_arg_fail(1)) SWIG_fail;
12733     {
12734         PyThreadState* __tstate = wxPyBeginAllowThreads();
12735         result = (int)((wxSpinButton const *)arg1)->GetMin();
12736
12737         wxPyEndAllowThreads(__tstate);
12738         if (PyErr_Occurred()) SWIG_fail;
12739     }
12740     {
12741         resultobj = SWIG_From_int((int)(result));
12742     }
12743     return resultobj;
12744     fail:
12745     return NULL;
12746 }
12747
12748
12749 static PyObject *_wrap_SpinButton_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
12750     PyObject *resultobj;
12751     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12752     int result;
12753     PyObject * obj0 = 0 ;
12754     char *kwnames[] = {
12755         (char *) "self", NULL
12756     };
12757
12758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_GetMax",kwnames,&obj0)) goto fail;
12759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12760     if (SWIG_arg_fail(1)) SWIG_fail;
12761     {
12762         PyThreadState* __tstate = wxPyBeginAllowThreads();
12763         result = (int)((wxSpinButton const *)arg1)->GetMax();
12764
12765         wxPyEndAllowThreads(__tstate);
12766         if (PyErr_Occurred()) SWIG_fail;
12767     }
12768     {
12769         resultobj = SWIG_From_int((int)(result));
12770     }
12771     return resultobj;
12772     fail:
12773     return NULL;
12774 }
12775
12776
12777 static PyObject *_wrap_SpinButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
12778     PyObject *resultobj;
12779     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12780     int arg2 ;
12781     PyObject * obj0 = 0 ;
12782     PyObject * obj1 = 0 ;
12783     char *kwnames[] = {
12784         (char *) "self",(char *) "val", NULL
12785     };
12786
12787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
12788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12789     if (SWIG_arg_fail(1)) SWIG_fail;
12790     {
12791         arg2 = (int)(SWIG_As_int(obj1));
12792         if (SWIG_arg_fail(2)) SWIG_fail;
12793     }
12794     {
12795         PyThreadState* __tstate = wxPyBeginAllowThreads();
12796         (arg1)->SetValue(arg2);
12797
12798         wxPyEndAllowThreads(__tstate);
12799         if (PyErr_Occurred()) SWIG_fail;
12800     }
12801     Py_INCREF(Py_None); resultobj = Py_None;
12802     return resultobj;
12803     fail:
12804     return NULL;
12805 }
12806
12807
12808 static PyObject *_wrap_SpinButton_SetMin(PyObject *, PyObject *args, PyObject *kwargs) {
12809     PyObject *resultobj;
12810     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12811     int arg2 ;
12812     PyObject * obj0 = 0 ;
12813     PyObject * obj1 = 0 ;
12814     char *kwnames[] = {
12815         (char *) "self",(char *) "minVal", NULL
12816     };
12817
12818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMin",kwnames,&obj0,&obj1)) goto fail;
12819     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12820     if (SWIG_arg_fail(1)) SWIG_fail;
12821     {
12822         arg2 = (int)(SWIG_As_int(obj1));
12823         if (SWIG_arg_fail(2)) SWIG_fail;
12824     }
12825     {
12826         PyThreadState* __tstate = wxPyBeginAllowThreads();
12827         (arg1)->SetMin(arg2);
12828
12829         wxPyEndAllowThreads(__tstate);
12830         if (PyErr_Occurred()) SWIG_fail;
12831     }
12832     Py_INCREF(Py_None); resultobj = Py_None;
12833     return resultobj;
12834     fail:
12835     return NULL;
12836 }
12837
12838
12839 static PyObject *_wrap_SpinButton_SetMax(PyObject *, PyObject *args, PyObject *kwargs) {
12840     PyObject *resultobj;
12841     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12842     int arg2 ;
12843     PyObject * obj0 = 0 ;
12844     PyObject * obj1 = 0 ;
12845     char *kwnames[] = {
12846         (char *) "self",(char *) "maxVal", NULL
12847     };
12848
12849     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMax",kwnames,&obj0,&obj1)) goto fail;
12850     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12851     if (SWIG_arg_fail(1)) SWIG_fail;
12852     {
12853         arg2 = (int)(SWIG_As_int(obj1));
12854         if (SWIG_arg_fail(2)) SWIG_fail;
12855     }
12856     {
12857         PyThreadState* __tstate = wxPyBeginAllowThreads();
12858         (arg1)->SetMax(arg2);
12859
12860         wxPyEndAllowThreads(__tstate);
12861         if (PyErr_Occurred()) SWIG_fail;
12862     }
12863     Py_INCREF(Py_None); resultobj = Py_None;
12864     return resultobj;
12865     fail:
12866     return NULL;
12867 }
12868
12869
12870 static PyObject *_wrap_SpinButton_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
12871     PyObject *resultobj;
12872     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12873     int arg2 ;
12874     int arg3 ;
12875     PyObject * obj0 = 0 ;
12876     PyObject * obj1 = 0 ;
12877     PyObject * obj2 = 0 ;
12878     char *kwnames[] = {
12879         (char *) "self",(char *) "minVal",(char *) "maxVal", NULL
12880     };
12881
12882     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinButton_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12883     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12884     if (SWIG_arg_fail(1)) SWIG_fail;
12885     {
12886         arg2 = (int)(SWIG_As_int(obj1));
12887         if (SWIG_arg_fail(2)) SWIG_fail;
12888     }
12889     {
12890         arg3 = (int)(SWIG_As_int(obj2));
12891         if (SWIG_arg_fail(3)) SWIG_fail;
12892     }
12893     {
12894         PyThreadState* __tstate = wxPyBeginAllowThreads();
12895         (arg1)->SetRange(arg2,arg3);
12896
12897         wxPyEndAllowThreads(__tstate);
12898         if (PyErr_Occurred()) SWIG_fail;
12899     }
12900     Py_INCREF(Py_None); resultobj = Py_None;
12901     return resultobj;
12902     fail:
12903     return NULL;
12904 }
12905
12906
12907 static PyObject *_wrap_SpinButton_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
12908     PyObject *resultobj;
12909     wxSpinButton *arg1 = (wxSpinButton *) 0 ;
12910     bool result;
12911     PyObject * obj0 = 0 ;
12912     char *kwnames[] = {
12913         (char *) "self", NULL
12914     };
12915
12916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinButton_IsVertical",kwnames,&obj0)) goto fail;
12917     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinButton, SWIG_POINTER_EXCEPTION | 0);
12918     if (SWIG_arg_fail(1)) SWIG_fail;
12919     {
12920         PyThreadState* __tstate = wxPyBeginAllowThreads();
12921         result = (bool)((wxSpinButton const *)arg1)->IsVertical();
12922
12923         wxPyEndAllowThreads(__tstate);
12924         if (PyErr_Occurred()) SWIG_fail;
12925     }
12926     {
12927         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12928     }
12929     return resultobj;
12930     fail:
12931     return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_SpinButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
12936     PyObject *resultobj;
12937     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
12938     wxVisualAttributes result;
12939     PyObject * obj0 = 0 ;
12940     char *kwnames[] = {
12941         (char *) "variant", NULL
12942     };
12943
12944     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
12945     if (obj0) {
12946         {
12947             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
12948             if (SWIG_arg_fail(1)) SWIG_fail;
12949         }
12950     }
12951     {
12952         if (!wxPyCheckForApp()) SWIG_fail;
12953         PyThreadState* __tstate = wxPyBeginAllowThreads();
12954         result = wxSpinButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
12955
12956         wxPyEndAllowThreads(__tstate);
12957         if (PyErr_Occurred()) SWIG_fail;
12958     }
12959     {
12960         wxVisualAttributes * resultptr;
12961         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
12962         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
12963     }
12964     return resultobj;
12965     fail:
12966     return NULL;
12967 }
12968
12969
12970 static PyObject * SpinButton_swigregister(PyObject *, PyObject *args) {
12971     PyObject *obj;
12972     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12973     SWIG_TypeClientData(SWIGTYPE_p_wxSpinButton, obj);
12974     Py_INCREF(obj);
12975     return Py_BuildValue((char *)"");
12976 }
12977 static PyObject *_wrap_new_SpinCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
12978     PyObject *resultobj;
12979     wxWindow *arg1 = (wxWindow *) 0 ;
12980     int arg2 = (int) -1 ;
12981     wxString const &arg3_defvalue = wxPyEmptyString ;
12982     wxString *arg3 = (wxString *) &arg3_defvalue ;
12983     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12984     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12985     wxSize const &arg5_defvalue = wxDefaultSize ;
12986     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12987     long arg6 = (long) wxSP_ARROW_KEYS ;
12988     int arg7 = (int) 0 ;
12989     int arg8 = (int) 100 ;
12990     int arg9 = (int) 0 ;
12991     wxString const &arg10_defvalue = wxPySpinCtrlNameStr ;
12992     wxString *arg10 = (wxString *) &arg10_defvalue ;
12993     wxSpinCtrl *result;
12994     bool temp3 = false ;
12995     wxPoint temp4 ;
12996     wxSize temp5 ;
12997     bool temp10 = false ;
12998     PyObject * obj0 = 0 ;
12999     PyObject * obj1 = 0 ;
13000     PyObject * obj2 = 0 ;
13001     PyObject * obj3 = 0 ;
13002     PyObject * obj4 = 0 ;
13003     PyObject * obj5 = 0 ;
13004     PyObject * obj6 = 0 ;
13005     PyObject * obj7 = 0 ;
13006     PyObject * obj8 = 0 ;
13007     PyObject * obj9 = 0 ;
13008     char *kwnames[] = {
13009         (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL
13010     };
13011
13012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_SpinCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
13013     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13014     if (SWIG_arg_fail(1)) SWIG_fail;
13015     if (obj1) {
13016         {
13017             arg2 = (int)(SWIG_As_int(obj1));
13018             if (SWIG_arg_fail(2)) SWIG_fail;
13019         }
13020     }
13021     if (obj2) {
13022         {
13023             arg3 = wxString_in_helper(obj2);
13024             if (arg3 == NULL) SWIG_fail;
13025             temp3 = true;
13026         }
13027     }
13028     if (obj3) {
13029         {
13030             arg4 = &temp4;
13031             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13032         }
13033     }
13034     if (obj4) {
13035         {
13036             arg5 = &temp5;
13037             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
13038         }
13039     }
13040     if (obj5) {
13041         {
13042             arg6 = (long)(SWIG_As_long(obj5));
13043             if (SWIG_arg_fail(6)) SWIG_fail;
13044         }
13045     }
13046     if (obj6) {
13047         {
13048             arg7 = (int)(SWIG_As_int(obj6));
13049             if (SWIG_arg_fail(7)) SWIG_fail;
13050         }
13051     }
13052     if (obj7) {
13053         {
13054             arg8 = (int)(SWIG_As_int(obj7));
13055             if (SWIG_arg_fail(8)) SWIG_fail;
13056         }
13057     }
13058     if (obj8) {
13059         {
13060             arg9 = (int)(SWIG_As_int(obj8));
13061             if (SWIG_arg_fail(9)) SWIG_fail;
13062         }
13063     }
13064     if (obj9) {
13065         {
13066             arg10 = wxString_in_helper(obj9);
13067             if (arg10 == NULL) SWIG_fail;
13068             temp10 = true;
13069         }
13070     }
13071     {
13072         if (!wxPyCheckForApp()) SWIG_fail;
13073         PyThreadState* __tstate = wxPyBeginAllowThreads();
13074         result = (wxSpinCtrl *)new wxSpinCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,arg7,arg8,arg9,(wxString const &)*arg10);
13075
13076         wxPyEndAllowThreads(__tstate);
13077         if (PyErr_Occurred()) SWIG_fail;
13078     }
13079     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinCtrl, 1);
13080     {
13081         if (temp3)
13082         delete arg3;
13083     }
13084     {
13085         if (temp10)
13086         delete arg10;
13087     }
13088     return resultobj;
13089     fail:
13090     {
13091         if (temp3)
13092         delete arg3;
13093     }
13094     {
13095         if (temp10)
13096         delete arg10;
13097     }
13098     return NULL;
13099 }
13100
13101
13102 static PyObject *_wrap_new_PreSpinCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
13103     PyObject *resultobj;
13104     wxSpinCtrl *result;
13105     char *kwnames[] = {
13106         NULL
13107     };
13108
13109     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSpinCtrl",kwnames)) goto fail;
13110     {
13111         if (!wxPyCheckForApp()) SWIG_fail;
13112         PyThreadState* __tstate = wxPyBeginAllowThreads();
13113         result = (wxSpinCtrl *)new wxSpinCtrl();
13114
13115         wxPyEndAllowThreads(__tstate);
13116         if (PyErr_Occurred()) SWIG_fail;
13117     }
13118     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinCtrl, 1);
13119     return resultobj;
13120     fail:
13121     return NULL;
13122 }
13123
13124
13125 static PyObject *_wrap_SpinCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13126     PyObject *resultobj;
13127     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13128     wxWindow *arg2 = (wxWindow *) 0 ;
13129     int arg3 = (int) -1 ;
13130     wxString const &arg4_defvalue = wxPyEmptyString ;
13131     wxString *arg4 = (wxString *) &arg4_defvalue ;
13132     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13133     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13134     wxSize const &arg6_defvalue = wxDefaultSize ;
13135     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13136     long arg7 = (long) wxSP_ARROW_KEYS ;
13137     int arg8 = (int) 0 ;
13138     int arg9 = (int) 100 ;
13139     int arg10 = (int) 0 ;
13140     wxString const &arg11_defvalue = wxPySpinCtrlNameStr ;
13141     wxString *arg11 = (wxString *) &arg11_defvalue ;
13142     bool result;
13143     bool temp4 = false ;
13144     wxPoint temp5 ;
13145     wxSize temp6 ;
13146     bool temp11 = false ;
13147     PyObject * obj0 = 0 ;
13148     PyObject * obj1 = 0 ;
13149     PyObject * obj2 = 0 ;
13150     PyObject * obj3 = 0 ;
13151     PyObject * obj4 = 0 ;
13152     PyObject * obj5 = 0 ;
13153     PyObject * obj6 = 0 ;
13154     PyObject * obj7 = 0 ;
13155     PyObject * obj8 = 0 ;
13156     PyObject * obj9 = 0 ;
13157     PyObject * obj10 = 0 ;
13158     char *kwnames[] = {
13159         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL
13160     };
13161
13162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:SpinCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
13163     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13164     if (SWIG_arg_fail(1)) SWIG_fail;
13165     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13166     if (SWIG_arg_fail(2)) SWIG_fail;
13167     if (obj2) {
13168         {
13169             arg3 = (int)(SWIG_As_int(obj2));
13170             if (SWIG_arg_fail(3)) SWIG_fail;
13171         }
13172     }
13173     if (obj3) {
13174         {
13175             arg4 = wxString_in_helper(obj3);
13176             if (arg4 == NULL) SWIG_fail;
13177             temp4 = true;
13178         }
13179     }
13180     if (obj4) {
13181         {
13182             arg5 = &temp5;
13183             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13184         }
13185     }
13186     if (obj5) {
13187         {
13188             arg6 = &temp6;
13189             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13190         }
13191     }
13192     if (obj6) {
13193         {
13194             arg7 = (long)(SWIG_As_long(obj6));
13195             if (SWIG_arg_fail(7)) SWIG_fail;
13196         }
13197     }
13198     if (obj7) {
13199         {
13200             arg8 = (int)(SWIG_As_int(obj7));
13201             if (SWIG_arg_fail(8)) SWIG_fail;
13202         }
13203     }
13204     if (obj8) {
13205         {
13206             arg9 = (int)(SWIG_As_int(obj8));
13207             if (SWIG_arg_fail(9)) SWIG_fail;
13208         }
13209     }
13210     if (obj9) {
13211         {
13212             arg10 = (int)(SWIG_As_int(obj9));
13213             if (SWIG_arg_fail(10)) SWIG_fail;
13214         }
13215     }
13216     if (obj10) {
13217         {
13218             arg11 = wxString_in_helper(obj10);
13219             if (arg11 == NULL) SWIG_fail;
13220             temp11 = true;
13221         }
13222     }
13223     {
13224         PyThreadState* __tstate = wxPyBeginAllowThreads();
13225         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,arg8,arg9,arg10,(wxString const &)*arg11);
13226
13227         wxPyEndAllowThreads(__tstate);
13228         if (PyErr_Occurred()) SWIG_fail;
13229     }
13230     {
13231         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13232     }
13233     {
13234         if (temp4)
13235         delete arg4;
13236     }
13237     {
13238         if (temp11)
13239         delete arg11;
13240     }
13241     return resultobj;
13242     fail:
13243     {
13244         if (temp4)
13245         delete arg4;
13246     }
13247     {
13248         if (temp11)
13249         delete arg11;
13250     }
13251     return NULL;
13252 }
13253
13254
13255 static PyObject *_wrap_SpinCtrl_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
13256     PyObject *resultobj;
13257     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13258     int result;
13259     PyObject * obj0 = 0 ;
13260     char *kwnames[] = {
13261         (char *) "self", NULL
13262     };
13263
13264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetValue",kwnames,&obj0)) goto fail;
13265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13266     if (SWIG_arg_fail(1)) SWIG_fail;
13267     {
13268         PyThreadState* __tstate = wxPyBeginAllowThreads();
13269         result = (int)((wxSpinCtrl const *)arg1)->GetValue();
13270
13271         wxPyEndAllowThreads(__tstate);
13272         if (PyErr_Occurred()) SWIG_fail;
13273     }
13274     {
13275         resultobj = SWIG_From_int((int)(result));
13276     }
13277     return resultobj;
13278     fail:
13279     return NULL;
13280 }
13281
13282
13283 static PyObject *_wrap_SpinCtrl_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
13284     PyObject *resultobj;
13285     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13286     int arg2 ;
13287     PyObject * obj0 = 0 ;
13288     PyObject * obj1 = 0 ;
13289     char *kwnames[] = {
13290         (char *) "self",(char *) "value", NULL
13291     };
13292
13293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValue",kwnames,&obj0,&obj1)) goto fail;
13294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13295     if (SWIG_arg_fail(1)) SWIG_fail;
13296     {
13297         arg2 = (int)(SWIG_As_int(obj1));
13298         if (SWIG_arg_fail(2)) SWIG_fail;
13299     }
13300     {
13301         PyThreadState* __tstate = wxPyBeginAllowThreads();
13302         (arg1)->SetValue(arg2);
13303
13304         wxPyEndAllowThreads(__tstate);
13305         if (PyErr_Occurred()) SWIG_fail;
13306     }
13307     Py_INCREF(Py_None); resultobj = Py_None;
13308     return resultobj;
13309     fail:
13310     return NULL;
13311 }
13312
13313
13314 static PyObject *_wrap_SpinCtrl_SetValueString(PyObject *, PyObject *args, PyObject *kwargs) {
13315     PyObject *resultobj;
13316     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13317     wxString *arg2 = 0 ;
13318     bool temp2 = false ;
13319     PyObject * obj0 = 0 ;
13320     PyObject * obj1 = 0 ;
13321     char *kwnames[] = {
13322         (char *) "self",(char *) "text", NULL
13323     };
13324
13325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValueString",kwnames,&obj0,&obj1)) goto fail;
13326     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13327     if (SWIG_arg_fail(1)) SWIG_fail;
13328     {
13329         arg2 = wxString_in_helper(obj1);
13330         if (arg2 == NULL) SWIG_fail;
13331         temp2 = true;
13332     }
13333     {
13334         PyThreadState* __tstate = wxPyBeginAllowThreads();
13335         (arg1)->SetValue((wxString const &)*arg2);
13336
13337         wxPyEndAllowThreads(__tstate);
13338         if (PyErr_Occurred()) SWIG_fail;
13339     }
13340     Py_INCREF(Py_None); resultobj = Py_None;
13341     {
13342         if (temp2)
13343         delete arg2;
13344     }
13345     return resultobj;
13346     fail:
13347     {
13348         if (temp2)
13349         delete arg2;
13350     }
13351     return NULL;
13352 }
13353
13354
13355 static PyObject *_wrap_SpinCtrl_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
13356     PyObject *resultobj;
13357     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13358     int arg2 ;
13359     int arg3 ;
13360     PyObject * obj0 = 0 ;
13361     PyObject * obj1 = 0 ;
13362     PyObject * obj2 = 0 ;
13363     char *kwnames[] = {
13364         (char *) "self",(char *) "minVal",(char *) "maxVal", NULL
13365     };
13366
13367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
13368     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13369     if (SWIG_arg_fail(1)) SWIG_fail;
13370     {
13371         arg2 = (int)(SWIG_As_int(obj1));
13372         if (SWIG_arg_fail(2)) SWIG_fail;
13373     }
13374     {
13375         arg3 = (int)(SWIG_As_int(obj2));
13376         if (SWIG_arg_fail(3)) SWIG_fail;
13377     }
13378     {
13379         PyThreadState* __tstate = wxPyBeginAllowThreads();
13380         (arg1)->SetRange(arg2,arg3);
13381
13382         wxPyEndAllowThreads(__tstate);
13383         if (PyErr_Occurred()) SWIG_fail;
13384     }
13385     Py_INCREF(Py_None); resultobj = Py_None;
13386     return resultobj;
13387     fail:
13388     return NULL;
13389 }
13390
13391
13392 static PyObject *_wrap_SpinCtrl_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
13393     PyObject *resultobj;
13394     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13395     int result;
13396     PyObject * obj0 = 0 ;
13397     char *kwnames[] = {
13398         (char *) "self", NULL
13399     };
13400
13401     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetMin",kwnames,&obj0)) goto fail;
13402     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13403     if (SWIG_arg_fail(1)) SWIG_fail;
13404     {
13405         PyThreadState* __tstate = wxPyBeginAllowThreads();
13406         result = (int)((wxSpinCtrl const *)arg1)->GetMin();
13407
13408         wxPyEndAllowThreads(__tstate);
13409         if (PyErr_Occurred()) SWIG_fail;
13410     }
13411     {
13412         resultobj = SWIG_From_int((int)(result));
13413     }
13414     return resultobj;
13415     fail:
13416     return NULL;
13417 }
13418
13419
13420 static PyObject *_wrap_SpinCtrl_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
13421     PyObject *resultobj;
13422     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13423     int result;
13424     PyObject * obj0 = 0 ;
13425     char *kwnames[] = {
13426         (char *) "self", NULL
13427     };
13428
13429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinCtrl_GetMax",kwnames,&obj0)) goto fail;
13430     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13431     if (SWIG_arg_fail(1)) SWIG_fail;
13432     {
13433         PyThreadState* __tstate = wxPyBeginAllowThreads();
13434         result = (int)((wxSpinCtrl const *)arg1)->GetMax();
13435
13436         wxPyEndAllowThreads(__tstate);
13437         if (PyErr_Occurred()) SWIG_fail;
13438     }
13439     {
13440         resultobj = SWIG_From_int((int)(result));
13441     }
13442     return resultobj;
13443     fail:
13444     return NULL;
13445 }
13446
13447
13448 static PyObject *_wrap_SpinCtrl_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
13449     PyObject *resultobj;
13450     wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
13451     long arg2 ;
13452     long arg3 ;
13453     PyObject * obj0 = 0 ;
13454     PyObject * obj1 = 0 ;
13455     PyObject * obj2 = 0 ;
13456     char *kwnames[] = {
13457         (char *) "self",(char *) "from",(char *) "to", NULL
13458     };
13459
13460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
13461     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_EXCEPTION | 0);
13462     if (SWIG_arg_fail(1)) SWIG_fail;
13463     {
13464         arg2 = (long)(SWIG_As_long(obj1));
13465         if (SWIG_arg_fail(2)) SWIG_fail;
13466     }
13467     {
13468         arg3 = (long)(SWIG_As_long(obj2));
13469         if (SWIG_arg_fail(3)) SWIG_fail;
13470     }
13471     {
13472         PyThreadState* __tstate = wxPyBeginAllowThreads();
13473         (arg1)->SetSelection(arg2,arg3);
13474
13475         wxPyEndAllowThreads(__tstate);
13476         if (PyErr_Occurred()) SWIG_fail;
13477     }
13478     Py_INCREF(Py_None); resultobj = Py_None;
13479     return resultobj;
13480     fail:
13481     return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_SpinCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
13486     PyObject *resultobj;
13487     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
13488     wxVisualAttributes result;
13489     PyObject * obj0 = 0 ;
13490     char *kwnames[] = {
13491         (char *) "variant", NULL
13492     };
13493
13494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
13495     if (obj0) {
13496         {
13497             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
13498             if (SWIG_arg_fail(1)) SWIG_fail;
13499         }
13500     }
13501     {
13502         if (!wxPyCheckForApp()) SWIG_fail;
13503         PyThreadState* __tstate = wxPyBeginAllowThreads();
13504         result = wxSpinCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
13505
13506         wxPyEndAllowThreads(__tstate);
13507         if (PyErr_Occurred()) SWIG_fail;
13508     }
13509     {
13510         wxVisualAttributes * resultptr;
13511         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
13512         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
13513     }
13514     return resultobj;
13515     fail:
13516     return NULL;
13517 }
13518
13519
13520 static PyObject * SpinCtrl_swigregister(PyObject *, PyObject *args) {
13521     PyObject *obj;
13522     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13523     SWIG_TypeClientData(SWIGTYPE_p_wxSpinCtrl, obj);
13524     Py_INCREF(obj);
13525     return Py_BuildValue((char *)"");
13526 }
13527 static PyObject *_wrap_new_SpinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13528     PyObject *resultobj;
13529     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13530     int arg2 = (int) 0 ;
13531     wxSpinEvent *result;
13532     PyObject * obj0 = 0 ;
13533     PyObject * obj1 = 0 ;
13534     char *kwnames[] = {
13535         (char *) "commandType",(char *) "winid", NULL
13536     };
13537
13538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SpinEvent",kwnames,&obj0,&obj1)) goto fail;
13539     if (obj0) {
13540         {
13541             arg1 = (wxEventType)(SWIG_As_int(obj0));
13542             if (SWIG_arg_fail(1)) SWIG_fail;
13543         }
13544     }
13545     if (obj1) {
13546         {
13547             arg2 = (int)(SWIG_As_int(obj1));
13548             if (SWIG_arg_fail(2)) SWIG_fail;
13549         }
13550     }
13551     {
13552         PyThreadState* __tstate = wxPyBeginAllowThreads();
13553         result = (wxSpinEvent *)new wxSpinEvent(arg1,arg2);
13554
13555         wxPyEndAllowThreads(__tstate);
13556         if (PyErr_Occurred()) SWIG_fail;
13557     }
13558     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSpinEvent, 1);
13559     return resultobj;
13560     fail:
13561     return NULL;
13562 }
13563
13564
13565 static PyObject *_wrap_SpinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13566     PyObject *resultobj;
13567     wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
13568     int result;
13569     PyObject * obj0 = 0 ;
13570     char *kwnames[] = {
13571         (char *) "self", NULL
13572     };
13573
13574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SpinEvent_GetPosition",kwnames,&obj0)) goto fail;
13575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinEvent, SWIG_POINTER_EXCEPTION | 0);
13576     if (SWIG_arg_fail(1)) SWIG_fail;
13577     {
13578         PyThreadState* __tstate = wxPyBeginAllowThreads();
13579         result = (int)((wxSpinEvent const *)arg1)->GetPosition();
13580
13581         wxPyEndAllowThreads(__tstate);
13582         if (PyErr_Occurred()) SWIG_fail;
13583     }
13584     {
13585         resultobj = SWIG_From_int((int)(result));
13586     }
13587     return resultobj;
13588     fail:
13589     return NULL;
13590 }
13591
13592
13593 static PyObject *_wrap_SpinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13594     PyObject *resultobj;
13595     wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
13596     int arg2 ;
13597     PyObject * obj0 = 0 ;
13598     PyObject * obj1 = 0 ;
13599     char *kwnames[] = {
13600         (char *) "self",(char *) "pos", NULL
13601     };
13602
13603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSpinEvent, SWIG_POINTER_EXCEPTION | 0);
13605     if (SWIG_arg_fail(1)) SWIG_fail;
13606     {
13607         arg2 = (int)(SWIG_As_int(obj1));
13608         if (SWIG_arg_fail(2)) SWIG_fail;
13609     }
13610     {
13611         PyThreadState* __tstate = wxPyBeginAllowThreads();
13612         (arg1)->SetPosition(arg2);
13613
13614         wxPyEndAllowThreads(__tstate);
13615         if (PyErr_Occurred()) SWIG_fail;
13616     }
13617     Py_INCREF(Py_None); resultobj = Py_None;
13618     return resultobj;
13619     fail:
13620     return NULL;
13621 }
13622
13623
13624 static PyObject * SpinEvent_swigregister(PyObject *, PyObject *args) {
13625     PyObject *obj;
13626     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13627     SWIG_TypeClientData(SWIGTYPE_p_wxSpinEvent, obj);
13628     Py_INCREF(obj);
13629     return Py_BuildValue((char *)"");
13630 }
13631 static int _wrap_RadioBoxNameStr_set(PyObject *) {
13632     PyErr_SetString(PyExc_TypeError,"Variable RadioBoxNameStr is read-only.");
13633     return 1;
13634 }
13635
13636
13637 static PyObject *_wrap_RadioBoxNameStr_get(void) {
13638     PyObject *pyobj;
13639
13640     {
13641 #if wxUSE_UNICODE
13642         pyobj = PyUnicode_FromWideChar((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
13643 #else
13644         pyobj = PyString_FromStringAndSize((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
13645 #endif
13646     }
13647     return pyobj;
13648 }
13649
13650
13651 static int _wrap_RadioButtonNameStr_set(PyObject *) {
13652     PyErr_SetString(PyExc_TypeError,"Variable RadioButtonNameStr is read-only.");
13653     return 1;
13654 }
13655
13656
13657 static PyObject *_wrap_RadioButtonNameStr_get(void) {
13658     PyObject *pyobj;
13659
13660     {
13661 #if wxUSE_UNICODE
13662         pyobj = PyUnicode_FromWideChar((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
13663 #else
13664         pyobj = PyString_FromStringAndSize((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
13665 #endif
13666     }
13667     return pyobj;
13668 }
13669
13670
13671 static PyObject *_wrap_new_RadioBox(PyObject *, PyObject *args, PyObject *kwargs) {
13672     PyObject *resultobj;
13673     wxWindow *arg1 = (wxWindow *) 0 ;
13674     int arg2 = (int) -1 ;
13675     wxString const &arg3_defvalue = wxPyEmptyString ;
13676     wxString *arg3 = (wxString *) &arg3_defvalue ;
13677     wxPoint const &arg4_defvalue = wxDefaultPosition ;
13678     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
13679     wxSize const &arg5_defvalue = wxDefaultSize ;
13680     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
13681     wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
13682     wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
13683     int arg7 = (int) 0 ;
13684     long arg8 = (long) wxRA_HORIZONTAL ;
13685     wxValidator const &arg9_defvalue = wxDefaultValidator ;
13686     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
13687     wxString const &arg10_defvalue = wxPyRadioBoxNameStr ;
13688     wxString *arg10 = (wxString *) &arg10_defvalue ;
13689     wxRadioBox *result;
13690     bool temp3 = false ;
13691     wxPoint temp4 ;
13692     wxSize temp5 ;
13693     bool temp6 = false ;
13694     bool temp10 = false ;
13695     PyObject * obj0 = 0 ;
13696     PyObject * obj1 = 0 ;
13697     PyObject * obj2 = 0 ;
13698     PyObject * obj3 = 0 ;
13699     PyObject * obj4 = 0 ;
13700     PyObject * obj5 = 0 ;
13701     PyObject * obj6 = 0 ;
13702     PyObject * obj7 = 0 ;
13703     PyObject * obj8 = 0 ;
13704     PyObject * obj9 = 0 ;
13705     char *kwnames[] = {
13706         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL
13707     };
13708
13709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_RadioBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
13710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13711     if (SWIG_arg_fail(1)) SWIG_fail;
13712     if (obj1) {
13713         {
13714             arg2 = (int)(SWIG_As_int(obj1));
13715             if (SWIG_arg_fail(2)) SWIG_fail;
13716         }
13717     }
13718     if (obj2) {
13719         {
13720             arg3 = wxString_in_helper(obj2);
13721             if (arg3 == NULL) SWIG_fail;
13722             temp3 = true;
13723         }
13724     }
13725     if (obj3) {
13726         {
13727             arg4 = &temp4;
13728             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13729         }
13730     }
13731     if (obj4) {
13732         {
13733             arg5 = &temp5;
13734             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
13735         }
13736     }
13737     if (obj5) {
13738         {
13739             if (! PySequence_Check(obj5)) {
13740                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13741                 SWIG_fail;
13742             }
13743             arg6 = new wxArrayString;
13744             temp6 = true;
13745             int i, len=PySequence_Length(obj5);
13746             for (i=0; i<len; i++) {
13747                 PyObject* item = PySequence_GetItem(obj5, i);
13748 #if wxUSE_UNICODE
13749                 PyObject* str  = PyObject_Unicode(item);
13750 #else
13751                 PyObject* str  = PyObject_Str(item);
13752 #endif
13753                 if (PyErr_Occurred())  SWIG_fail;
13754                 arg6->Add(Py2wxString(str));
13755                 Py_DECREF(item);
13756                 Py_DECREF(str);
13757             }
13758         }
13759     }
13760     if (obj6) {
13761         {
13762             arg7 = (int)(SWIG_As_int(obj6));
13763             if (SWIG_arg_fail(7)) SWIG_fail;
13764         }
13765     }
13766     if (obj7) {
13767         {
13768             arg8 = (long)(SWIG_As_long(obj7));
13769             if (SWIG_arg_fail(8)) SWIG_fail;
13770         }
13771     }
13772     if (obj8) {
13773         {
13774             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
13775             if (SWIG_arg_fail(9)) SWIG_fail;
13776             if (arg9 == NULL) {
13777                 SWIG_null_ref("wxValidator");
13778             }
13779             if (SWIG_arg_fail(9)) SWIG_fail;
13780         }
13781     }
13782     if (obj9) {
13783         {
13784             arg10 = wxString_in_helper(obj9);
13785             if (arg10 == NULL) SWIG_fail;
13786             temp10 = true;
13787         }
13788     }
13789     {
13790         if (!wxPyCheckForApp()) SWIG_fail;
13791         PyThreadState* __tstate = wxPyBeginAllowThreads();
13792         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);
13793
13794         wxPyEndAllowThreads(__tstate);
13795         if (PyErr_Occurred()) SWIG_fail;
13796     }
13797     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioBox, 1);
13798     {
13799         if (temp3)
13800         delete arg3;
13801     }
13802     {
13803         if (temp6) delete arg6;
13804     }
13805     {
13806         if (temp10)
13807         delete arg10;
13808     }
13809     return resultobj;
13810     fail:
13811     {
13812         if (temp3)
13813         delete arg3;
13814     }
13815     {
13816         if (temp6) delete arg6;
13817     }
13818     {
13819         if (temp10)
13820         delete arg10;
13821     }
13822     return NULL;
13823 }
13824
13825
13826 static PyObject *_wrap_new_PreRadioBox(PyObject *, PyObject *args, PyObject *kwargs) {
13827     PyObject *resultobj;
13828     wxRadioBox *result;
13829     char *kwnames[] = {
13830         NULL
13831     };
13832
13833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreRadioBox",kwnames)) goto fail;
13834     {
13835         if (!wxPyCheckForApp()) SWIG_fail;
13836         PyThreadState* __tstate = wxPyBeginAllowThreads();
13837         result = (wxRadioBox *)new wxRadioBox();
13838
13839         wxPyEndAllowThreads(__tstate);
13840         if (PyErr_Occurred()) SWIG_fail;
13841     }
13842     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioBox, 1);
13843     return resultobj;
13844     fail:
13845     return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_RadioBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13850     PyObject *resultobj;
13851     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
13852     wxWindow *arg2 = (wxWindow *) 0 ;
13853     int arg3 = (int) -1 ;
13854     wxString const &arg4_defvalue = wxPyEmptyString ;
13855     wxString *arg4 = (wxString *) &arg4_defvalue ;
13856     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13857     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13858     wxSize const &arg6_defvalue = wxDefaultSize ;
13859     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13860     wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
13861     wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
13862     int arg8 = (int) 0 ;
13863     long arg9 = (long) wxRA_HORIZONTAL ;
13864     wxValidator const &arg10_defvalue = wxDefaultValidator ;
13865     wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
13866     wxString const &arg11_defvalue = wxPyRadioBoxNameStr ;
13867     wxString *arg11 = (wxString *) &arg11_defvalue ;
13868     bool result;
13869     bool temp4 = false ;
13870     wxPoint temp5 ;
13871     wxSize temp6 ;
13872     bool temp7 = false ;
13873     bool temp11 = false ;
13874     PyObject * obj0 = 0 ;
13875     PyObject * obj1 = 0 ;
13876     PyObject * obj2 = 0 ;
13877     PyObject * obj3 = 0 ;
13878     PyObject * obj4 = 0 ;
13879     PyObject * obj5 = 0 ;
13880     PyObject * obj6 = 0 ;
13881     PyObject * obj7 = 0 ;
13882     PyObject * obj8 = 0 ;
13883     PyObject * obj9 = 0 ;
13884     PyObject * obj10 = 0 ;
13885     char *kwnames[] = {
13886         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL
13887     };
13888
13889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:RadioBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
13890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
13891     if (SWIG_arg_fail(1)) SWIG_fail;
13892     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13893     if (SWIG_arg_fail(2)) SWIG_fail;
13894     if (obj2) {
13895         {
13896             arg3 = (int)(SWIG_As_int(obj2));
13897             if (SWIG_arg_fail(3)) SWIG_fail;
13898         }
13899     }
13900     if (obj3) {
13901         {
13902             arg4 = wxString_in_helper(obj3);
13903             if (arg4 == NULL) SWIG_fail;
13904             temp4 = true;
13905         }
13906     }
13907     if (obj4) {
13908         {
13909             arg5 = &temp5;
13910             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13911         }
13912     }
13913     if (obj5) {
13914         {
13915             arg6 = &temp6;
13916             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13917         }
13918     }
13919     if (obj6) {
13920         {
13921             if (! PySequence_Check(obj6)) {
13922                 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13923                 SWIG_fail;
13924             }
13925             arg7 = new wxArrayString;
13926             temp7 = true;
13927             int i, len=PySequence_Length(obj6);
13928             for (i=0; i<len; i++) {
13929                 PyObject* item = PySequence_GetItem(obj6, i);
13930 #if wxUSE_UNICODE
13931                 PyObject* str  = PyObject_Unicode(item);
13932 #else
13933                 PyObject* str  = PyObject_Str(item);
13934 #endif
13935                 if (PyErr_Occurred())  SWIG_fail;
13936                 arg7->Add(Py2wxString(str));
13937                 Py_DECREF(item);
13938                 Py_DECREF(str);
13939             }
13940         }
13941     }
13942     if (obj7) {
13943         {
13944             arg8 = (int)(SWIG_As_int(obj7));
13945             if (SWIG_arg_fail(8)) SWIG_fail;
13946         }
13947     }
13948     if (obj8) {
13949         {
13950             arg9 = (long)(SWIG_As_long(obj8));
13951             if (SWIG_arg_fail(9)) SWIG_fail;
13952         }
13953     }
13954     if (obj9) {
13955         {
13956             SWIG_Python_ConvertPtr(obj9, (void **)&arg10, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
13957             if (SWIG_arg_fail(10)) SWIG_fail;
13958             if (arg10 == NULL) {
13959                 SWIG_null_ref("wxValidator");
13960             }
13961             if (SWIG_arg_fail(10)) SWIG_fail;
13962         }
13963     }
13964     if (obj10) {
13965         {
13966             arg11 = wxString_in_helper(obj10);
13967             if (arg11 == NULL) SWIG_fail;
13968             temp11 = true;
13969         }
13970     }
13971     {
13972         PyThreadState* __tstate = wxPyBeginAllowThreads();
13973         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);
13974
13975         wxPyEndAllowThreads(__tstate);
13976         if (PyErr_Occurred()) SWIG_fail;
13977     }
13978     {
13979         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13980     }
13981     {
13982         if (temp4)
13983         delete arg4;
13984     }
13985     {
13986         if (temp7) delete arg7;
13987     }
13988     {
13989         if (temp11)
13990         delete arg11;
13991     }
13992     return resultobj;
13993     fail:
13994     {
13995         if (temp4)
13996         delete arg4;
13997     }
13998     {
13999         if (temp7) delete arg7;
14000     }
14001     {
14002         if (temp11)
14003         delete arg11;
14004     }
14005     return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_RadioBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14010     PyObject *resultobj;
14011     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14012     int arg2 ;
14013     PyObject * obj0 = 0 ;
14014     PyObject * obj1 = 0 ;
14015     char *kwnames[] = {
14016         (char *) "self",(char *) "n", NULL
14017     };
14018
14019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14020     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14021     if (SWIG_arg_fail(1)) SWIG_fail;
14022     {
14023         arg2 = (int)(SWIG_As_int(obj1));
14024         if (SWIG_arg_fail(2)) SWIG_fail;
14025     }
14026     {
14027         PyThreadState* __tstate = wxPyBeginAllowThreads();
14028         (arg1)->SetSelection(arg2);
14029
14030         wxPyEndAllowThreads(__tstate);
14031         if (PyErr_Occurred()) SWIG_fail;
14032     }
14033     Py_INCREF(Py_None); resultobj = Py_None;
14034     return resultobj;
14035     fail:
14036     return NULL;
14037 }
14038
14039
14040 static PyObject *_wrap_RadioBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14041     PyObject *resultobj;
14042     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14043     int result;
14044     PyObject * obj0 = 0 ;
14045     char *kwnames[] = {
14046         (char *) "self", NULL
14047     };
14048
14049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetSelection",kwnames,&obj0)) goto fail;
14050     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14051     if (SWIG_arg_fail(1)) SWIG_fail;
14052     {
14053         PyThreadState* __tstate = wxPyBeginAllowThreads();
14054         result = (int)((wxRadioBox const *)arg1)->GetSelection();
14055
14056         wxPyEndAllowThreads(__tstate);
14057         if (PyErr_Occurred()) SWIG_fail;
14058     }
14059     {
14060         resultobj = SWIG_From_int((int)(result));
14061     }
14062     return resultobj;
14063     fail:
14064     return NULL;
14065 }
14066
14067
14068 static PyObject *_wrap_RadioBox_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14069     PyObject *resultobj;
14070     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14071     wxString result;
14072     PyObject * obj0 = 0 ;
14073     char *kwnames[] = {
14074         (char *) "self", NULL
14075     };
14076
14077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetStringSelection",kwnames,&obj0)) goto fail;
14078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14079     if (SWIG_arg_fail(1)) SWIG_fail;
14080     {
14081         PyThreadState* __tstate = wxPyBeginAllowThreads();
14082         result = ((wxRadioBox const *)arg1)->GetStringSelection();
14083
14084         wxPyEndAllowThreads(__tstate);
14085         if (PyErr_Occurred()) SWIG_fail;
14086     }
14087     {
14088 #if wxUSE_UNICODE
14089         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14090 #else
14091         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14092 #endif
14093     }
14094     return resultobj;
14095     fail:
14096     return NULL;
14097 }
14098
14099
14100 static PyObject *_wrap_RadioBox_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14101     PyObject *resultobj;
14102     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14103     wxString *arg2 = 0 ;
14104     bool result;
14105     bool temp2 = false ;
14106     PyObject * obj0 = 0 ;
14107     PyObject * obj1 = 0 ;
14108     char *kwnames[] = {
14109         (char *) "self",(char *) "s", NULL
14110     };
14111
14112     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
14113     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14114     if (SWIG_arg_fail(1)) SWIG_fail;
14115     {
14116         arg2 = wxString_in_helper(obj1);
14117         if (arg2 == NULL) SWIG_fail;
14118         temp2 = true;
14119     }
14120     {
14121         PyThreadState* __tstate = wxPyBeginAllowThreads();
14122         result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
14123
14124         wxPyEndAllowThreads(__tstate);
14125         if (PyErr_Occurred()) SWIG_fail;
14126     }
14127     {
14128         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14129     }
14130     {
14131         if (temp2)
14132         delete arg2;
14133     }
14134     return resultobj;
14135     fail:
14136     {
14137         if (temp2)
14138         delete arg2;
14139     }
14140     return NULL;
14141 }
14142
14143
14144 static PyObject *_wrap_RadioBox_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
14145     PyObject *resultobj;
14146     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14147     int result;
14148     PyObject * obj0 = 0 ;
14149     char *kwnames[] = {
14150         (char *) "self", NULL
14151     };
14152
14153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetCount",kwnames,&obj0)) goto fail;
14154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14155     if (SWIG_arg_fail(1)) SWIG_fail;
14156     {
14157         PyThreadState* __tstate = wxPyBeginAllowThreads();
14158         result = (int)((wxRadioBox const *)arg1)->GetCount();
14159
14160         wxPyEndAllowThreads(__tstate);
14161         if (PyErr_Occurred()) SWIG_fail;
14162     }
14163     {
14164         resultobj = SWIG_From_int((int)(result));
14165     }
14166     return resultobj;
14167     fail:
14168     return NULL;
14169 }
14170
14171
14172 static PyObject *_wrap_RadioBox_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
14173     PyObject *resultobj;
14174     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14175     wxString *arg2 = 0 ;
14176     int result;
14177     bool temp2 = false ;
14178     PyObject * obj0 = 0 ;
14179     PyObject * obj1 = 0 ;
14180     char *kwnames[] = {
14181         (char *) "self",(char *) "s", NULL
14182     };
14183
14184     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_FindString",kwnames,&obj0,&obj1)) goto fail;
14185     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14186     if (SWIG_arg_fail(1)) SWIG_fail;
14187     {
14188         arg2 = wxString_in_helper(obj1);
14189         if (arg2 == NULL) SWIG_fail;
14190         temp2 = true;
14191     }
14192     {
14193         PyThreadState* __tstate = wxPyBeginAllowThreads();
14194         result = (int)((wxRadioBox const *)arg1)->FindString((wxString const &)*arg2);
14195
14196         wxPyEndAllowThreads(__tstate);
14197         if (PyErr_Occurred()) SWIG_fail;
14198     }
14199     {
14200         resultobj = SWIG_From_int((int)(result));
14201     }
14202     {
14203         if (temp2)
14204         delete arg2;
14205     }
14206     return resultobj;
14207     fail:
14208     {
14209         if (temp2)
14210         delete arg2;
14211     }
14212     return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_RadioBox_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14217     PyObject *resultobj;
14218     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14219     int arg2 ;
14220     wxString result;
14221     PyObject * obj0 = 0 ;
14222     PyObject * obj1 = 0 ;
14223     char *kwnames[] = {
14224         (char *) "self",(char *) "n", NULL
14225     };
14226
14227     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_GetString",kwnames,&obj0,&obj1)) goto fail;
14228     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14229     if (SWIG_arg_fail(1)) SWIG_fail;
14230     {
14231         arg2 = (int)(SWIG_As_int(obj1));
14232         if (SWIG_arg_fail(2)) SWIG_fail;
14233     }
14234     {
14235         PyThreadState* __tstate = wxPyBeginAllowThreads();
14236         result = ((wxRadioBox const *)arg1)->GetString(arg2);
14237
14238         wxPyEndAllowThreads(__tstate);
14239         if (PyErr_Occurred()) SWIG_fail;
14240     }
14241     {
14242 #if wxUSE_UNICODE
14243         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14244 #else
14245         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14246 #endif
14247     }
14248     return resultobj;
14249     fail:
14250     return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_RadioBox_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14255     PyObject *resultobj;
14256     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14257     int arg2 ;
14258     wxString *arg3 = 0 ;
14259     bool temp3 = false ;
14260     PyObject * obj0 = 0 ;
14261     PyObject * obj1 = 0 ;
14262     PyObject * obj2 = 0 ;
14263     char *kwnames[] = {
14264         (char *) "self",(char *) "n",(char *) "label", NULL
14265     };
14266
14267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RadioBox_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
14268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14269     if (SWIG_arg_fail(1)) SWIG_fail;
14270     {
14271         arg2 = (int)(SWIG_As_int(obj1));
14272         if (SWIG_arg_fail(2)) SWIG_fail;
14273     }
14274     {
14275         arg3 = wxString_in_helper(obj2);
14276         if (arg3 == NULL) SWIG_fail;
14277         temp3 = true;
14278     }
14279     {
14280         PyThreadState* __tstate = wxPyBeginAllowThreads();
14281         (arg1)->SetString(arg2,(wxString const &)*arg3);
14282
14283         wxPyEndAllowThreads(__tstate);
14284         if (PyErr_Occurred()) SWIG_fail;
14285     }
14286     Py_INCREF(Py_None); resultobj = Py_None;
14287     {
14288         if (temp3)
14289         delete arg3;
14290     }
14291     return resultobj;
14292     fail:
14293     {
14294         if (temp3)
14295         delete arg3;
14296     }
14297     return NULL;
14298 }
14299
14300
14301 static PyObject *_wrap_RadioBox_EnableItem(PyObject *, PyObject *args, PyObject *kwargs) {
14302     PyObject *resultobj;
14303     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14304     int arg2 ;
14305     bool arg3 = (bool) true ;
14306     PyObject * obj0 = 0 ;
14307     PyObject * obj1 = 0 ;
14308     PyObject * obj2 = 0 ;
14309     char *kwnames[] = {
14310         (char *) "self",(char *) "n",(char *) "enable", NULL
14311     };
14312
14313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_EnableItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
14314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14315     if (SWIG_arg_fail(1)) SWIG_fail;
14316     {
14317         arg2 = (int)(SWIG_As_int(obj1));
14318         if (SWIG_arg_fail(2)) SWIG_fail;
14319     }
14320     if (obj2) {
14321         {
14322             arg3 = (bool)(SWIG_As_bool(obj2));
14323             if (SWIG_arg_fail(3)) SWIG_fail;
14324         }
14325     }
14326     {
14327         PyThreadState* __tstate = wxPyBeginAllowThreads();
14328         (arg1)->Enable(arg2,arg3);
14329
14330         wxPyEndAllowThreads(__tstate);
14331         if (PyErr_Occurred()) SWIG_fail;
14332     }
14333     Py_INCREF(Py_None); resultobj = Py_None;
14334     return resultobj;
14335     fail:
14336     return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_RadioBox_ShowItem(PyObject *, PyObject *args, PyObject *kwargs) {
14341     PyObject *resultobj;
14342     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14343     int arg2 ;
14344     bool arg3 = (bool) true ;
14345     PyObject * obj0 = 0 ;
14346     PyObject * obj1 = 0 ;
14347     PyObject * obj2 = 0 ;
14348     char *kwnames[] = {
14349         (char *) "self",(char *) "n",(char *) "show", NULL
14350     };
14351
14352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_ShowItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
14353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14354     if (SWIG_arg_fail(1)) SWIG_fail;
14355     {
14356         arg2 = (int)(SWIG_As_int(obj1));
14357         if (SWIG_arg_fail(2)) SWIG_fail;
14358     }
14359     if (obj2) {
14360         {
14361             arg3 = (bool)(SWIG_As_bool(obj2));
14362             if (SWIG_arg_fail(3)) SWIG_fail;
14363         }
14364     }
14365     {
14366         PyThreadState* __tstate = wxPyBeginAllowThreads();
14367         (arg1)->Show(arg2,arg3);
14368
14369         wxPyEndAllowThreads(__tstate);
14370         if (PyErr_Occurred()) SWIG_fail;
14371     }
14372     Py_INCREF(Py_None); resultobj = Py_None;
14373     return resultobj;
14374     fail:
14375     return NULL;
14376 }
14377
14378
14379 static PyObject *_wrap_RadioBox_GetColumnCount(PyObject *, PyObject *args, PyObject *kwargs) {
14380     PyObject *resultobj;
14381     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14382     int result;
14383     PyObject * obj0 = 0 ;
14384     char *kwnames[] = {
14385         (char *) "self", NULL
14386     };
14387
14388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetColumnCount",kwnames,&obj0)) goto fail;
14389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14390     if (SWIG_arg_fail(1)) SWIG_fail;
14391     {
14392         PyThreadState* __tstate = wxPyBeginAllowThreads();
14393         result = (int)((wxRadioBox const *)arg1)->GetColumnCount();
14394
14395         wxPyEndAllowThreads(__tstate);
14396         if (PyErr_Occurred()) SWIG_fail;
14397     }
14398     {
14399         resultobj = SWIG_From_int((int)(result));
14400     }
14401     return resultobj;
14402     fail:
14403     return NULL;
14404 }
14405
14406
14407 static PyObject *_wrap_RadioBox_GetRowCount(PyObject *, PyObject *args, PyObject *kwargs) {
14408     PyObject *resultobj;
14409     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14410     int result;
14411     PyObject * obj0 = 0 ;
14412     char *kwnames[] = {
14413         (char *) "self", NULL
14414     };
14415
14416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioBox_GetRowCount",kwnames,&obj0)) goto fail;
14417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14418     if (SWIG_arg_fail(1)) SWIG_fail;
14419     {
14420         PyThreadState* __tstate = wxPyBeginAllowThreads();
14421         result = (int)((wxRadioBox const *)arg1)->GetRowCount();
14422
14423         wxPyEndAllowThreads(__tstate);
14424         if (PyErr_Occurred()) SWIG_fail;
14425     }
14426     {
14427         resultobj = SWIG_From_int((int)(result));
14428     }
14429     return resultobj;
14430     fail:
14431     return NULL;
14432 }
14433
14434
14435 static PyObject *_wrap_RadioBox_GetNextItem(PyObject *, PyObject *args, PyObject *kwargs) {
14436     PyObject *resultobj;
14437     wxRadioBox *arg1 = (wxRadioBox *) 0 ;
14438     int arg2 ;
14439     wxDirection arg3 ;
14440     long arg4 ;
14441     int result;
14442     PyObject * obj0 = 0 ;
14443     PyObject * obj1 = 0 ;
14444     PyObject * obj2 = 0 ;
14445     PyObject * obj3 = 0 ;
14446     char *kwnames[] = {
14447         (char *) "self",(char *) "item",(char *) "dir",(char *) "style", NULL
14448     };
14449
14450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RadioBox_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioBox, SWIG_POINTER_EXCEPTION | 0);
14452     if (SWIG_arg_fail(1)) SWIG_fail;
14453     {
14454         arg2 = (int)(SWIG_As_int(obj1));
14455         if (SWIG_arg_fail(2)) SWIG_fail;
14456     }
14457     {
14458         arg3 = (wxDirection)(SWIG_As_int(obj2));
14459         if (SWIG_arg_fail(3)) SWIG_fail;
14460     }
14461     {
14462         arg4 = (long)(SWIG_As_long(obj3));
14463         if (SWIG_arg_fail(4)) SWIG_fail;
14464     }
14465     {
14466         PyThreadState* __tstate = wxPyBeginAllowThreads();
14467         result = (int)((wxRadioBox const *)arg1)->GetNextItem(arg2,(wxDirection )arg3,arg4);
14468
14469         wxPyEndAllowThreads(__tstate);
14470         if (PyErr_Occurred()) SWIG_fail;
14471     }
14472     {
14473         resultobj = SWIG_From_int((int)(result));
14474     }
14475     return resultobj;
14476     fail:
14477     return NULL;
14478 }
14479
14480
14481 static PyObject *_wrap_RadioBox_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
14482     PyObject *resultobj;
14483     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
14484     wxVisualAttributes result;
14485     PyObject * obj0 = 0 ;
14486     char *kwnames[] = {
14487         (char *) "variant", NULL
14488     };
14489
14490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioBox_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
14491     if (obj0) {
14492         {
14493             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
14494             if (SWIG_arg_fail(1)) SWIG_fail;
14495         }
14496     }
14497     {
14498         if (!wxPyCheckForApp()) SWIG_fail;
14499         PyThreadState* __tstate = wxPyBeginAllowThreads();
14500         result = wxRadioBox::GetClassDefaultAttributes((wxWindowVariant )arg1);
14501
14502         wxPyEndAllowThreads(__tstate);
14503         if (PyErr_Occurred()) SWIG_fail;
14504     }
14505     {
14506         wxVisualAttributes * resultptr;
14507         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
14508         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
14509     }
14510     return resultobj;
14511     fail:
14512     return NULL;
14513 }
14514
14515
14516 static PyObject * RadioBox_swigregister(PyObject *, PyObject *args) {
14517     PyObject *obj;
14518     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14519     SWIG_TypeClientData(SWIGTYPE_p_wxRadioBox, obj);
14520     Py_INCREF(obj);
14521     return Py_BuildValue((char *)"");
14522 }
14523 static PyObject *_wrap_new_RadioButton(PyObject *, PyObject *args, PyObject *kwargs) {
14524     PyObject *resultobj;
14525     wxWindow *arg1 = (wxWindow *) 0 ;
14526     int arg2 = (int) -1 ;
14527     wxString const &arg3_defvalue = wxPyEmptyString ;
14528     wxString *arg3 = (wxString *) &arg3_defvalue ;
14529     wxPoint const &arg4_defvalue = wxDefaultPosition ;
14530     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
14531     wxSize const &arg5_defvalue = wxDefaultSize ;
14532     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
14533     long arg6 = (long) 0 ;
14534     wxValidator const &arg7_defvalue = wxDefaultValidator ;
14535     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
14536     wxString const &arg8_defvalue = wxPyRadioButtonNameStr ;
14537     wxString *arg8 = (wxString *) &arg8_defvalue ;
14538     wxRadioButton *result;
14539     bool temp3 = false ;
14540     wxPoint temp4 ;
14541     wxSize temp5 ;
14542     bool temp8 = false ;
14543     PyObject * obj0 = 0 ;
14544     PyObject * obj1 = 0 ;
14545     PyObject * obj2 = 0 ;
14546     PyObject * obj3 = 0 ;
14547     PyObject * obj4 = 0 ;
14548     PyObject * obj5 = 0 ;
14549     PyObject * obj6 = 0 ;
14550     PyObject * obj7 = 0 ;
14551     char *kwnames[] = {
14552         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14553     };
14554
14555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_RadioButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14557     if (SWIG_arg_fail(1)) SWIG_fail;
14558     if (obj1) {
14559         {
14560             arg2 = (int)(SWIG_As_int(obj1));
14561             if (SWIG_arg_fail(2)) SWIG_fail;
14562         }
14563     }
14564     if (obj2) {
14565         {
14566             arg3 = wxString_in_helper(obj2);
14567             if (arg3 == NULL) SWIG_fail;
14568             temp3 = true;
14569         }
14570     }
14571     if (obj3) {
14572         {
14573             arg4 = &temp4;
14574             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
14575         }
14576     }
14577     if (obj4) {
14578         {
14579             arg5 = &temp5;
14580             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
14581         }
14582     }
14583     if (obj5) {
14584         {
14585             arg6 = (long)(SWIG_As_long(obj5));
14586             if (SWIG_arg_fail(6)) SWIG_fail;
14587         }
14588     }
14589     if (obj6) {
14590         {
14591             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14592             if (SWIG_arg_fail(7)) SWIG_fail;
14593             if (arg7 == NULL) {
14594                 SWIG_null_ref("wxValidator");
14595             }
14596             if (SWIG_arg_fail(7)) SWIG_fail;
14597         }
14598     }
14599     if (obj7) {
14600         {
14601             arg8 = wxString_in_helper(obj7);
14602             if (arg8 == NULL) SWIG_fail;
14603             temp8 = true;
14604         }
14605     }
14606     {
14607         if (!wxPyCheckForApp()) SWIG_fail;
14608         PyThreadState* __tstate = wxPyBeginAllowThreads();
14609         result = (wxRadioButton *)new wxRadioButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
14610
14611         wxPyEndAllowThreads(__tstate);
14612         if (PyErr_Occurred()) SWIG_fail;
14613     }
14614     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioButton, 1);
14615     {
14616         if (temp3)
14617         delete arg3;
14618     }
14619     {
14620         if (temp8)
14621         delete arg8;
14622     }
14623     return resultobj;
14624     fail:
14625     {
14626         if (temp3)
14627         delete arg3;
14628     }
14629     {
14630         if (temp8)
14631         delete arg8;
14632     }
14633     return NULL;
14634 }
14635
14636
14637 static PyObject *_wrap_new_PreRadioButton(PyObject *, PyObject *args, PyObject *kwargs) {
14638     PyObject *resultobj;
14639     wxRadioButton *result;
14640     char *kwnames[] = {
14641         NULL
14642     };
14643
14644     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreRadioButton",kwnames)) goto fail;
14645     {
14646         if (!wxPyCheckForApp()) SWIG_fail;
14647         PyThreadState* __tstate = wxPyBeginAllowThreads();
14648         result = (wxRadioButton *)new wxRadioButton();
14649
14650         wxPyEndAllowThreads(__tstate);
14651         if (PyErr_Occurred()) SWIG_fail;
14652     }
14653     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRadioButton, 1);
14654     return resultobj;
14655     fail:
14656     return NULL;
14657 }
14658
14659
14660 static PyObject *_wrap_RadioButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14661     PyObject *resultobj;
14662     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14663     wxWindow *arg2 = (wxWindow *) 0 ;
14664     int arg3 = (int) -1 ;
14665     wxString const &arg4_defvalue = wxPyEmptyString ;
14666     wxString *arg4 = (wxString *) &arg4_defvalue ;
14667     wxPoint const &arg5_defvalue = wxDefaultPosition ;
14668     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
14669     wxSize const &arg6_defvalue = wxDefaultSize ;
14670     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
14671     long arg7 = (long) 0 ;
14672     wxValidator const &arg8_defvalue = wxDefaultValidator ;
14673     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
14674     wxString const &arg9_defvalue = wxPyRadioButtonNameStr ;
14675     wxString *arg9 = (wxString *) &arg9_defvalue ;
14676     bool result;
14677     bool temp4 = false ;
14678     wxPoint temp5 ;
14679     wxSize temp6 ;
14680     bool temp9 = false ;
14681     PyObject * obj0 = 0 ;
14682     PyObject * obj1 = 0 ;
14683     PyObject * obj2 = 0 ;
14684     PyObject * obj3 = 0 ;
14685     PyObject * obj4 = 0 ;
14686     PyObject * obj5 = 0 ;
14687     PyObject * obj6 = 0 ;
14688     PyObject * obj7 = 0 ;
14689     PyObject * obj8 = 0 ;
14690     char *kwnames[] = {
14691         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14692     };
14693
14694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:RadioButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
14695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14696     if (SWIG_arg_fail(1)) SWIG_fail;
14697     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14698     if (SWIG_arg_fail(2)) SWIG_fail;
14699     if (obj2) {
14700         {
14701             arg3 = (int)(SWIG_As_int(obj2));
14702             if (SWIG_arg_fail(3)) SWIG_fail;
14703         }
14704     }
14705     if (obj3) {
14706         {
14707             arg4 = wxString_in_helper(obj3);
14708             if (arg4 == NULL) SWIG_fail;
14709             temp4 = true;
14710         }
14711     }
14712     if (obj4) {
14713         {
14714             arg5 = &temp5;
14715             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14716         }
14717     }
14718     if (obj5) {
14719         {
14720             arg6 = &temp6;
14721             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
14722         }
14723     }
14724     if (obj6) {
14725         {
14726             arg7 = (long)(SWIG_As_long(obj6));
14727             if (SWIG_arg_fail(7)) SWIG_fail;
14728         }
14729     }
14730     if (obj7) {
14731         {
14732             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14733             if (SWIG_arg_fail(8)) SWIG_fail;
14734             if (arg8 == NULL) {
14735                 SWIG_null_ref("wxValidator");
14736             }
14737             if (SWIG_arg_fail(8)) SWIG_fail;
14738         }
14739     }
14740     if (obj8) {
14741         {
14742             arg9 = wxString_in_helper(obj8);
14743             if (arg9 == NULL) SWIG_fail;
14744             temp9 = true;
14745         }
14746     }
14747     {
14748         PyThreadState* __tstate = wxPyBeginAllowThreads();
14749         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
14750
14751         wxPyEndAllowThreads(__tstate);
14752         if (PyErr_Occurred()) SWIG_fail;
14753     }
14754     {
14755         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14756     }
14757     {
14758         if (temp4)
14759         delete arg4;
14760     }
14761     {
14762         if (temp9)
14763         delete arg9;
14764     }
14765     return resultobj;
14766     fail:
14767     {
14768         if (temp4)
14769         delete arg4;
14770     }
14771     {
14772         if (temp9)
14773         delete arg9;
14774     }
14775     return NULL;
14776 }
14777
14778
14779 static PyObject *_wrap_RadioButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
14780     PyObject *resultobj;
14781     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14782     bool result;
14783     PyObject * obj0 = 0 ;
14784     char *kwnames[] = {
14785         (char *) "self", NULL
14786     };
14787
14788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RadioButton_GetValue",kwnames,&obj0)) goto fail;
14789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14790     if (SWIG_arg_fail(1)) SWIG_fail;
14791     {
14792         PyThreadState* __tstate = wxPyBeginAllowThreads();
14793         result = (bool)(arg1)->GetValue();
14794
14795         wxPyEndAllowThreads(__tstate);
14796         if (PyErr_Occurred()) SWIG_fail;
14797     }
14798     {
14799         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14800     }
14801     return resultobj;
14802     fail:
14803     return NULL;
14804 }
14805
14806
14807 static PyObject *_wrap_RadioButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
14808     PyObject *resultobj;
14809     wxRadioButton *arg1 = (wxRadioButton *) 0 ;
14810     bool arg2 ;
14811     PyObject * obj0 = 0 ;
14812     PyObject * obj1 = 0 ;
14813     char *kwnames[] = {
14814         (char *) "self",(char *) "value", NULL
14815     };
14816
14817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
14818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRadioButton, SWIG_POINTER_EXCEPTION | 0);
14819     if (SWIG_arg_fail(1)) SWIG_fail;
14820     {
14821         arg2 = (bool)(SWIG_As_bool(obj1));
14822         if (SWIG_arg_fail(2)) SWIG_fail;
14823     }
14824     {
14825         PyThreadState* __tstate = wxPyBeginAllowThreads();
14826         (arg1)->SetValue(arg2);
14827
14828         wxPyEndAllowThreads(__tstate);
14829         if (PyErr_Occurred()) SWIG_fail;
14830     }
14831     Py_INCREF(Py_None); resultobj = Py_None;
14832     return resultobj;
14833     fail:
14834     return NULL;
14835 }
14836
14837
14838 static PyObject *_wrap_RadioButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
14839     PyObject *resultobj;
14840     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
14841     wxVisualAttributes result;
14842     PyObject * obj0 = 0 ;
14843     char *kwnames[] = {
14844         (char *) "variant", NULL
14845     };
14846
14847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
14848     if (obj0) {
14849         {
14850             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
14851             if (SWIG_arg_fail(1)) SWIG_fail;
14852         }
14853     }
14854     {
14855         if (!wxPyCheckForApp()) SWIG_fail;
14856         PyThreadState* __tstate = wxPyBeginAllowThreads();
14857         result = wxRadioButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
14858
14859         wxPyEndAllowThreads(__tstate);
14860         if (PyErr_Occurred()) SWIG_fail;
14861     }
14862     {
14863         wxVisualAttributes * resultptr;
14864         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
14865         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
14866     }
14867     return resultobj;
14868     fail:
14869     return NULL;
14870 }
14871
14872
14873 static PyObject * RadioButton_swigregister(PyObject *, PyObject *args) {
14874     PyObject *obj;
14875     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14876     SWIG_TypeClientData(SWIGTYPE_p_wxRadioButton, obj);
14877     Py_INCREF(obj);
14878     return Py_BuildValue((char *)"");
14879 }
14880 static int _wrap_SliderNameStr_set(PyObject *) {
14881     PyErr_SetString(PyExc_TypeError,"Variable SliderNameStr is read-only.");
14882     return 1;
14883 }
14884
14885
14886 static PyObject *_wrap_SliderNameStr_get(void) {
14887     PyObject *pyobj;
14888
14889     {
14890 #if wxUSE_UNICODE
14891         pyobj = PyUnicode_FromWideChar((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
14892 #else
14893         pyobj = PyString_FromStringAndSize((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
14894 #endif
14895     }
14896     return pyobj;
14897 }
14898
14899
14900 static PyObject *_wrap_new_Slider(PyObject *, PyObject *args, PyObject *kwargs) {
14901     PyObject *resultobj;
14902     wxWindow *arg1 = (wxWindow *) 0 ;
14903     int arg2 = (int) -1 ;
14904     int arg3 = (int) 0 ;
14905     int arg4 = (int) 0 ;
14906     int arg5 = (int) 100 ;
14907     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14908     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14909     wxSize const &arg7_defvalue = wxDefaultSize ;
14910     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
14911     long arg8 = (long) wxSL_HORIZONTAL ;
14912     wxValidator const &arg9_defvalue = wxDefaultValidator ;
14913     wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
14914     wxString const &arg10_defvalue = wxPySliderNameStr ;
14915     wxString *arg10 = (wxString *) &arg10_defvalue ;
14916     wxSlider *result;
14917     wxPoint temp6 ;
14918     wxSize temp7 ;
14919     bool temp10 = false ;
14920     PyObject * obj0 = 0 ;
14921     PyObject * obj1 = 0 ;
14922     PyObject * obj2 = 0 ;
14923     PyObject * obj3 = 0 ;
14924     PyObject * obj4 = 0 ;
14925     PyObject * obj5 = 0 ;
14926     PyObject * obj6 = 0 ;
14927     PyObject * obj7 = 0 ;
14928     PyObject * obj8 = 0 ;
14929     PyObject * obj9 = 0 ;
14930     char *kwnames[] = {
14931         (char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
14932     };
14933
14934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_Slider",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
14935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14936     if (SWIG_arg_fail(1)) SWIG_fail;
14937     if (obj1) {
14938         {
14939             arg2 = (int)(SWIG_As_int(obj1));
14940             if (SWIG_arg_fail(2)) SWIG_fail;
14941         }
14942     }
14943     if (obj2) {
14944         {
14945             arg3 = (int)(SWIG_As_int(obj2));
14946             if (SWIG_arg_fail(3)) SWIG_fail;
14947         }
14948     }
14949     if (obj3) {
14950         {
14951             arg4 = (int)(SWIG_As_int(obj3));
14952             if (SWIG_arg_fail(4)) SWIG_fail;
14953         }
14954     }
14955     if (obj4) {
14956         {
14957             arg5 = (int)(SWIG_As_int(obj4));
14958             if (SWIG_arg_fail(5)) SWIG_fail;
14959         }
14960     }
14961     if (obj5) {
14962         {
14963             arg6 = &temp6;
14964             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
14965         }
14966     }
14967     if (obj6) {
14968         {
14969             arg7 = &temp7;
14970             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
14971         }
14972     }
14973     if (obj7) {
14974         {
14975             arg8 = (long)(SWIG_As_long(obj7));
14976             if (SWIG_arg_fail(8)) SWIG_fail;
14977         }
14978     }
14979     if (obj8) {
14980         {
14981             SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
14982             if (SWIG_arg_fail(9)) SWIG_fail;
14983             if (arg9 == NULL) {
14984                 SWIG_null_ref("wxValidator");
14985             }
14986             if (SWIG_arg_fail(9)) SWIG_fail;
14987         }
14988     }
14989     if (obj9) {
14990         {
14991             arg10 = wxString_in_helper(obj9);
14992             if (arg10 == NULL) SWIG_fail;
14993             temp10 = true;
14994         }
14995     }
14996     {
14997         if (!wxPyCheckForApp()) SWIG_fail;
14998         PyThreadState* __tstate = wxPyBeginAllowThreads();
14999         result = (wxSlider *)new wxSlider(arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
15000
15001         wxPyEndAllowThreads(__tstate);
15002         if (PyErr_Occurred()) SWIG_fail;
15003     }
15004     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSlider, 1);
15005     {
15006         if (temp10)
15007         delete arg10;
15008     }
15009     return resultobj;
15010     fail:
15011     {
15012         if (temp10)
15013         delete arg10;
15014     }
15015     return NULL;
15016 }
15017
15018
15019 static PyObject *_wrap_new_PreSlider(PyObject *, PyObject *args, PyObject *kwargs) {
15020     PyObject *resultobj;
15021     wxSlider *result;
15022     char *kwnames[] = {
15023         NULL
15024     };
15025
15026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSlider",kwnames)) goto fail;
15027     {
15028         if (!wxPyCheckForApp()) SWIG_fail;
15029         PyThreadState* __tstate = wxPyBeginAllowThreads();
15030         result = (wxSlider *)new wxSlider();
15031
15032         wxPyEndAllowThreads(__tstate);
15033         if (PyErr_Occurred()) SWIG_fail;
15034     }
15035     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSlider, 1);
15036     return resultobj;
15037     fail:
15038     return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_Slider_Create(PyObject *, PyObject *args, PyObject *kwargs) {
15043     PyObject *resultobj;
15044     wxSlider *arg1 = (wxSlider *) 0 ;
15045     wxWindow *arg2 = (wxWindow *) 0 ;
15046     int arg3 = (int) -1 ;
15047     int arg4 = (int) 0 ;
15048     int arg5 = (int) 0 ;
15049     int arg6 = (int) 100 ;
15050     wxPoint const &arg7_defvalue = wxDefaultPosition ;
15051     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
15052     wxSize const &arg8_defvalue = wxDefaultSize ;
15053     wxSize *arg8 = (wxSize *) &arg8_defvalue ;
15054     long arg9 = (long) wxSL_HORIZONTAL ;
15055     wxValidator const &arg10_defvalue = wxDefaultValidator ;
15056     wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
15057     wxString const &arg11_defvalue = wxPySliderNameStr ;
15058     wxString *arg11 = (wxString *) &arg11_defvalue ;
15059     bool result;
15060     wxPoint temp7 ;
15061     wxSize temp8 ;
15062     bool temp11 = false ;
15063     PyObject * obj0 = 0 ;
15064     PyObject * obj1 = 0 ;
15065     PyObject * obj2 = 0 ;
15066     PyObject * obj3 = 0 ;
15067     PyObject * obj4 = 0 ;
15068     PyObject * obj5 = 0 ;
15069     PyObject * obj6 = 0 ;
15070     PyObject * obj7 = 0 ;
15071     PyObject * obj8 = 0 ;
15072     PyObject * obj9 = 0 ;
15073     PyObject * obj10 = 0 ;
15074     char *kwnames[] = {
15075         (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
15076     };
15077
15078     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:Slider_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
15079     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15080     if (SWIG_arg_fail(1)) SWIG_fail;
15081     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15082     if (SWIG_arg_fail(2)) SWIG_fail;
15083     if (obj2) {
15084         {
15085             arg3 = (int)(SWIG_As_int(obj2));
15086             if (SWIG_arg_fail(3)) SWIG_fail;
15087         }
15088     }
15089     if (obj3) {
15090         {
15091             arg4 = (int)(SWIG_As_int(obj3));
15092             if (SWIG_arg_fail(4)) SWIG_fail;
15093         }
15094     }
15095     if (obj4) {
15096         {
15097             arg5 = (int)(SWIG_As_int(obj4));
15098             if (SWIG_arg_fail(5)) SWIG_fail;
15099         }
15100     }
15101     if (obj5) {
15102         {
15103             arg6 = (int)(SWIG_As_int(obj5));
15104             if (SWIG_arg_fail(6)) SWIG_fail;
15105         }
15106     }
15107     if (obj6) {
15108         {
15109             arg7 = &temp7;
15110             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
15111         }
15112     }
15113     if (obj7) {
15114         {
15115             arg8 = &temp8;
15116             if ( ! wxSize_helper(obj7, &arg8)) SWIG_fail;
15117         }
15118     }
15119     if (obj8) {
15120         {
15121             arg9 = (long)(SWIG_As_long(obj8));
15122             if (SWIG_arg_fail(9)) SWIG_fail;
15123         }
15124     }
15125     if (obj9) {
15126         {
15127             SWIG_Python_ConvertPtr(obj9, (void **)&arg10, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
15128             if (SWIG_arg_fail(10)) SWIG_fail;
15129             if (arg10 == NULL) {
15130                 SWIG_null_ref("wxValidator");
15131             }
15132             if (SWIG_arg_fail(10)) SWIG_fail;
15133         }
15134     }
15135     if (obj10) {
15136         {
15137             arg11 = wxString_in_helper(obj10);
15138             if (arg11 == NULL) SWIG_fail;
15139             temp11 = true;
15140         }
15141     }
15142     {
15143         PyThreadState* __tstate = wxPyBeginAllowThreads();
15144         result = (bool)(arg1)->Create(arg2,arg3,arg4,arg5,arg6,(wxPoint const &)*arg7,(wxSize const &)*arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
15145
15146         wxPyEndAllowThreads(__tstate);
15147         if (PyErr_Occurred()) SWIG_fail;
15148     }
15149     {
15150         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15151     }
15152     {
15153         if (temp11)
15154         delete arg11;
15155     }
15156     return resultobj;
15157     fail:
15158     {
15159         if (temp11)
15160         delete arg11;
15161     }
15162     return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_Slider_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15167     PyObject *resultobj;
15168     wxSlider *arg1 = (wxSlider *) 0 ;
15169     int result;
15170     PyObject * obj0 = 0 ;
15171     char *kwnames[] = {
15172         (char *) "self", NULL
15173     };
15174
15175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetValue",kwnames,&obj0)) goto fail;
15176     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15177     if (SWIG_arg_fail(1)) SWIG_fail;
15178     {
15179         PyThreadState* __tstate = wxPyBeginAllowThreads();
15180         result = (int)((wxSlider const *)arg1)->GetValue();
15181
15182         wxPyEndAllowThreads(__tstate);
15183         if (PyErr_Occurred()) SWIG_fail;
15184     }
15185     {
15186         resultobj = SWIG_From_int((int)(result));
15187     }
15188     return resultobj;
15189     fail:
15190     return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_Slider_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15195     PyObject *resultobj;
15196     wxSlider *arg1 = (wxSlider *) 0 ;
15197     int arg2 ;
15198     PyObject * obj0 = 0 ;
15199     PyObject * obj1 = 0 ;
15200     char *kwnames[] = {
15201         (char *) "self",(char *) "value", NULL
15202     };
15203
15204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetValue",kwnames,&obj0,&obj1)) goto fail;
15205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15206     if (SWIG_arg_fail(1)) SWIG_fail;
15207     {
15208         arg2 = (int)(SWIG_As_int(obj1));
15209         if (SWIG_arg_fail(2)) SWIG_fail;
15210     }
15211     {
15212         PyThreadState* __tstate = wxPyBeginAllowThreads();
15213         (arg1)->SetValue(arg2);
15214
15215         wxPyEndAllowThreads(__tstate);
15216         if (PyErr_Occurred()) SWIG_fail;
15217     }
15218     Py_INCREF(Py_None); resultobj = Py_None;
15219     return resultobj;
15220     fail:
15221     return NULL;
15222 }
15223
15224
15225 static PyObject *_wrap_Slider_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15226     PyObject *resultobj;
15227     wxSlider *arg1 = (wxSlider *) 0 ;
15228     int arg2 ;
15229     int arg3 ;
15230     PyObject * obj0 = 0 ;
15231     PyObject * obj1 = 0 ;
15232     PyObject * obj2 = 0 ;
15233     char *kwnames[] = {
15234         (char *) "self",(char *) "minValue",(char *) "maxValue", NULL
15235     };
15236
15237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15238     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15239     if (SWIG_arg_fail(1)) SWIG_fail;
15240     {
15241         arg2 = (int)(SWIG_As_int(obj1));
15242         if (SWIG_arg_fail(2)) SWIG_fail;
15243     }
15244     {
15245         arg3 = (int)(SWIG_As_int(obj2));
15246         if (SWIG_arg_fail(3)) SWIG_fail;
15247     }
15248     {
15249         PyThreadState* __tstate = wxPyBeginAllowThreads();
15250         (arg1)->SetRange(arg2,arg3);
15251
15252         wxPyEndAllowThreads(__tstate);
15253         if (PyErr_Occurred()) SWIG_fail;
15254     }
15255     Py_INCREF(Py_None); resultobj = Py_None;
15256     return resultobj;
15257     fail:
15258     return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_Slider_GetMin(PyObject *, PyObject *args, PyObject *kwargs) {
15263     PyObject *resultobj;
15264     wxSlider *arg1 = (wxSlider *) 0 ;
15265     int result;
15266     PyObject * obj0 = 0 ;
15267     char *kwnames[] = {
15268         (char *) "self", NULL
15269     };
15270
15271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetMin",kwnames,&obj0)) goto fail;
15272     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15273     if (SWIG_arg_fail(1)) SWIG_fail;
15274     {
15275         PyThreadState* __tstate = wxPyBeginAllowThreads();
15276         result = (int)((wxSlider const *)arg1)->GetMin();
15277
15278         wxPyEndAllowThreads(__tstate);
15279         if (PyErr_Occurred()) SWIG_fail;
15280     }
15281     {
15282         resultobj = SWIG_From_int((int)(result));
15283     }
15284     return resultobj;
15285     fail:
15286     return NULL;
15287 }
15288
15289
15290 static PyObject *_wrap_Slider_GetMax(PyObject *, PyObject *args, PyObject *kwargs) {
15291     PyObject *resultobj;
15292     wxSlider *arg1 = (wxSlider *) 0 ;
15293     int result;
15294     PyObject * obj0 = 0 ;
15295     char *kwnames[] = {
15296         (char *) "self", NULL
15297     };
15298
15299     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetMax",kwnames,&obj0)) goto fail;
15300     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15301     if (SWIG_arg_fail(1)) SWIG_fail;
15302     {
15303         PyThreadState* __tstate = wxPyBeginAllowThreads();
15304         result = (int)((wxSlider const *)arg1)->GetMax();
15305
15306         wxPyEndAllowThreads(__tstate);
15307         if (PyErr_Occurred()) SWIG_fail;
15308     }
15309     {
15310         resultobj = SWIG_From_int((int)(result));
15311     }
15312     return resultobj;
15313     fail:
15314     return NULL;
15315 }
15316
15317
15318 static PyObject *_wrap_Slider_SetMin(PyObject *, PyObject *args, PyObject *kwargs) {
15319     PyObject *resultobj;
15320     wxSlider *arg1 = (wxSlider *) 0 ;
15321     int arg2 ;
15322     PyObject * obj0 = 0 ;
15323     PyObject * obj1 = 0 ;
15324     char *kwnames[] = {
15325         (char *) "self",(char *) "minValue", NULL
15326     };
15327
15328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMin",kwnames,&obj0,&obj1)) goto fail;
15329     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15330     if (SWIG_arg_fail(1)) SWIG_fail;
15331     {
15332         arg2 = (int)(SWIG_As_int(obj1));
15333         if (SWIG_arg_fail(2)) SWIG_fail;
15334     }
15335     {
15336         PyThreadState* __tstate = wxPyBeginAllowThreads();
15337         (arg1)->SetMin(arg2);
15338
15339         wxPyEndAllowThreads(__tstate);
15340         if (PyErr_Occurred()) SWIG_fail;
15341     }
15342     Py_INCREF(Py_None); resultobj = Py_None;
15343     return resultobj;
15344     fail:
15345     return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_Slider_SetMax(PyObject *, PyObject *args, PyObject *kwargs) {
15350     PyObject *resultobj;
15351     wxSlider *arg1 = (wxSlider *) 0 ;
15352     int arg2 ;
15353     PyObject * obj0 = 0 ;
15354     PyObject * obj1 = 0 ;
15355     char *kwnames[] = {
15356         (char *) "self",(char *) "maxValue", NULL
15357     };
15358
15359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMax",kwnames,&obj0,&obj1)) goto fail;
15360     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15361     if (SWIG_arg_fail(1)) SWIG_fail;
15362     {
15363         arg2 = (int)(SWIG_As_int(obj1));
15364         if (SWIG_arg_fail(2)) SWIG_fail;
15365     }
15366     {
15367         PyThreadState* __tstate = wxPyBeginAllowThreads();
15368         (arg1)->SetMax(arg2);
15369
15370         wxPyEndAllowThreads(__tstate);
15371         if (PyErr_Occurred()) SWIG_fail;
15372     }
15373     Py_INCREF(Py_None); resultobj = Py_None;
15374     return resultobj;
15375     fail:
15376     return NULL;
15377 }
15378
15379
15380 static PyObject *_wrap_Slider_SetLineSize(PyObject *, PyObject *args, PyObject *kwargs) {
15381     PyObject *resultobj;
15382     wxSlider *arg1 = (wxSlider *) 0 ;
15383     int arg2 ;
15384     PyObject * obj0 = 0 ;
15385     PyObject * obj1 = 0 ;
15386     char *kwnames[] = {
15387         (char *) "self",(char *) "lineSize", NULL
15388     };
15389
15390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetLineSize",kwnames,&obj0,&obj1)) goto fail;
15391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15392     if (SWIG_arg_fail(1)) SWIG_fail;
15393     {
15394         arg2 = (int)(SWIG_As_int(obj1));
15395         if (SWIG_arg_fail(2)) SWIG_fail;
15396     }
15397     {
15398         PyThreadState* __tstate = wxPyBeginAllowThreads();
15399         (arg1)->SetLineSize(arg2);
15400
15401         wxPyEndAllowThreads(__tstate);
15402         if (PyErr_Occurred()) SWIG_fail;
15403     }
15404     Py_INCREF(Py_None); resultobj = Py_None;
15405     return resultobj;
15406     fail:
15407     return NULL;
15408 }
15409
15410
15411 static PyObject *_wrap_Slider_SetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
15412     PyObject *resultobj;
15413     wxSlider *arg1 = (wxSlider *) 0 ;
15414     int arg2 ;
15415     PyObject * obj0 = 0 ;
15416     PyObject * obj1 = 0 ;
15417     char *kwnames[] = {
15418         (char *) "self",(char *) "pageSize", NULL
15419     };
15420
15421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetPageSize",kwnames,&obj0,&obj1)) goto fail;
15422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15423     if (SWIG_arg_fail(1)) SWIG_fail;
15424     {
15425         arg2 = (int)(SWIG_As_int(obj1));
15426         if (SWIG_arg_fail(2)) SWIG_fail;
15427     }
15428     {
15429         PyThreadState* __tstate = wxPyBeginAllowThreads();
15430         (arg1)->SetPageSize(arg2);
15431
15432         wxPyEndAllowThreads(__tstate);
15433         if (PyErr_Occurred()) SWIG_fail;
15434     }
15435     Py_INCREF(Py_None); resultobj = Py_None;
15436     return resultobj;
15437     fail:
15438     return NULL;
15439 }
15440
15441
15442 static PyObject *_wrap_Slider_GetLineSize(PyObject *, PyObject *args, PyObject *kwargs) {
15443     PyObject *resultobj;
15444     wxSlider *arg1 = (wxSlider *) 0 ;
15445     int result;
15446     PyObject * obj0 = 0 ;
15447     char *kwnames[] = {
15448         (char *) "self", NULL
15449     };
15450
15451     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetLineSize",kwnames,&obj0)) goto fail;
15452     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15453     if (SWIG_arg_fail(1)) SWIG_fail;
15454     {
15455         PyThreadState* __tstate = wxPyBeginAllowThreads();
15456         result = (int)((wxSlider const *)arg1)->GetLineSize();
15457
15458         wxPyEndAllowThreads(__tstate);
15459         if (PyErr_Occurred()) SWIG_fail;
15460     }
15461     {
15462         resultobj = SWIG_From_int((int)(result));
15463     }
15464     return resultobj;
15465     fail:
15466     return NULL;
15467 }
15468
15469
15470 static PyObject *_wrap_Slider_GetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
15471     PyObject *resultobj;
15472     wxSlider *arg1 = (wxSlider *) 0 ;
15473     int result;
15474     PyObject * obj0 = 0 ;
15475     char *kwnames[] = {
15476         (char *) "self", NULL
15477     };
15478
15479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetPageSize",kwnames,&obj0)) goto fail;
15480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15481     if (SWIG_arg_fail(1)) SWIG_fail;
15482     {
15483         PyThreadState* __tstate = wxPyBeginAllowThreads();
15484         result = (int)((wxSlider const *)arg1)->GetPageSize();
15485
15486         wxPyEndAllowThreads(__tstate);
15487         if (PyErr_Occurred()) SWIG_fail;
15488     }
15489     {
15490         resultobj = SWIG_From_int((int)(result));
15491     }
15492     return resultobj;
15493     fail:
15494     return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_Slider_SetThumbLength(PyObject *, PyObject *args, PyObject *kwargs) {
15499     PyObject *resultobj;
15500     wxSlider *arg1 = (wxSlider *) 0 ;
15501     int arg2 ;
15502     PyObject * obj0 = 0 ;
15503     PyObject * obj1 = 0 ;
15504     char *kwnames[] = {
15505         (char *) "self",(char *) "lenPixels", NULL
15506     };
15507
15508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetThumbLength",kwnames,&obj0,&obj1)) goto fail;
15509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15510     if (SWIG_arg_fail(1)) SWIG_fail;
15511     {
15512         arg2 = (int)(SWIG_As_int(obj1));
15513         if (SWIG_arg_fail(2)) SWIG_fail;
15514     }
15515     {
15516         PyThreadState* __tstate = wxPyBeginAllowThreads();
15517         (arg1)->SetThumbLength(arg2);
15518
15519         wxPyEndAllowThreads(__tstate);
15520         if (PyErr_Occurred()) SWIG_fail;
15521     }
15522     Py_INCREF(Py_None); resultobj = Py_None;
15523     return resultobj;
15524     fail:
15525     return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_Slider_GetThumbLength(PyObject *, PyObject *args, PyObject *kwargs) {
15530     PyObject *resultobj;
15531     wxSlider *arg1 = (wxSlider *) 0 ;
15532     int result;
15533     PyObject * obj0 = 0 ;
15534     char *kwnames[] = {
15535         (char *) "self", NULL
15536     };
15537
15538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetThumbLength",kwnames,&obj0)) goto fail;
15539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15540     if (SWIG_arg_fail(1)) SWIG_fail;
15541     {
15542         PyThreadState* __tstate = wxPyBeginAllowThreads();
15543         result = (int)((wxSlider const *)arg1)->GetThumbLength();
15544
15545         wxPyEndAllowThreads(__tstate);
15546         if (PyErr_Occurred()) SWIG_fail;
15547     }
15548     {
15549         resultobj = SWIG_From_int((int)(result));
15550     }
15551     return resultobj;
15552     fail:
15553     return NULL;
15554 }
15555
15556
15557 static PyObject *_wrap_Slider_SetTickFreq(PyObject *, PyObject *args, PyObject *kwargs) {
15558     PyObject *resultobj;
15559     wxSlider *arg1 = (wxSlider *) 0 ;
15560     int arg2 ;
15561     int arg3 = (int) 1 ;
15562     PyObject * obj0 = 0 ;
15563     PyObject * obj1 = 0 ;
15564     PyObject * obj2 = 0 ;
15565     char *kwnames[] = {
15566         (char *) "self",(char *) "n",(char *) "pos", NULL
15567     };
15568
15569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Slider_SetTickFreq",kwnames,&obj0,&obj1,&obj2)) goto fail;
15570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15571     if (SWIG_arg_fail(1)) SWIG_fail;
15572     {
15573         arg2 = (int)(SWIG_As_int(obj1));
15574         if (SWIG_arg_fail(2)) SWIG_fail;
15575     }
15576     if (obj2) {
15577         {
15578             arg3 = (int)(SWIG_As_int(obj2));
15579             if (SWIG_arg_fail(3)) SWIG_fail;
15580         }
15581     }
15582     {
15583         PyThreadState* __tstate = wxPyBeginAllowThreads();
15584         (arg1)->SetTickFreq(arg2,arg3);
15585
15586         wxPyEndAllowThreads(__tstate);
15587         if (PyErr_Occurred()) SWIG_fail;
15588     }
15589     Py_INCREF(Py_None); resultobj = Py_None;
15590     return resultobj;
15591     fail:
15592     return NULL;
15593 }
15594
15595
15596 static PyObject *_wrap_Slider_GetTickFreq(PyObject *, PyObject *args, PyObject *kwargs) {
15597     PyObject *resultobj;
15598     wxSlider *arg1 = (wxSlider *) 0 ;
15599     int result;
15600     PyObject * obj0 = 0 ;
15601     char *kwnames[] = {
15602         (char *) "self", NULL
15603     };
15604
15605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetTickFreq",kwnames,&obj0)) goto fail;
15606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15607     if (SWIG_arg_fail(1)) SWIG_fail;
15608     {
15609         PyThreadState* __tstate = wxPyBeginAllowThreads();
15610         result = (int)((wxSlider const *)arg1)->GetTickFreq();
15611
15612         wxPyEndAllowThreads(__tstate);
15613         if (PyErr_Occurred()) SWIG_fail;
15614     }
15615     {
15616         resultobj = SWIG_From_int((int)(result));
15617     }
15618     return resultobj;
15619     fail:
15620     return NULL;
15621 }
15622
15623
15624 static PyObject *_wrap_Slider_ClearTicks(PyObject *, PyObject *args, PyObject *kwargs) {
15625     PyObject *resultobj;
15626     wxSlider *arg1 = (wxSlider *) 0 ;
15627     PyObject * obj0 = 0 ;
15628     char *kwnames[] = {
15629         (char *) "self", NULL
15630     };
15631
15632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_ClearTicks",kwnames,&obj0)) goto fail;
15633     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15634     if (SWIG_arg_fail(1)) SWIG_fail;
15635     {
15636         PyThreadState* __tstate = wxPyBeginAllowThreads();
15637         (arg1)->ClearTicks();
15638
15639         wxPyEndAllowThreads(__tstate);
15640         if (PyErr_Occurred()) SWIG_fail;
15641     }
15642     Py_INCREF(Py_None); resultobj = Py_None;
15643     return resultobj;
15644     fail:
15645     return NULL;
15646 }
15647
15648
15649 static PyObject *_wrap_Slider_SetTick(PyObject *, PyObject *args, PyObject *kwargs) {
15650     PyObject *resultobj;
15651     wxSlider *arg1 = (wxSlider *) 0 ;
15652     int arg2 ;
15653     PyObject * obj0 = 0 ;
15654     PyObject * obj1 = 0 ;
15655     char *kwnames[] = {
15656         (char *) "self",(char *) "tickPos", NULL
15657     };
15658
15659     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetTick",kwnames,&obj0,&obj1)) goto fail;
15660     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15661     if (SWIG_arg_fail(1)) SWIG_fail;
15662     {
15663         arg2 = (int)(SWIG_As_int(obj1));
15664         if (SWIG_arg_fail(2)) SWIG_fail;
15665     }
15666     {
15667         PyThreadState* __tstate = wxPyBeginAllowThreads();
15668         (arg1)->SetTick(arg2);
15669
15670         wxPyEndAllowThreads(__tstate);
15671         if (PyErr_Occurred()) SWIG_fail;
15672     }
15673     Py_INCREF(Py_None); resultobj = Py_None;
15674     return resultobj;
15675     fail:
15676     return NULL;
15677 }
15678
15679
15680 static PyObject *_wrap_Slider_ClearSel(PyObject *, PyObject *args, PyObject *kwargs) {
15681     PyObject *resultobj;
15682     wxSlider *arg1 = (wxSlider *) 0 ;
15683     PyObject * obj0 = 0 ;
15684     char *kwnames[] = {
15685         (char *) "self", NULL
15686     };
15687
15688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_ClearSel",kwnames,&obj0)) goto fail;
15689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15690     if (SWIG_arg_fail(1)) SWIG_fail;
15691     {
15692         PyThreadState* __tstate = wxPyBeginAllowThreads();
15693         (arg1)->ClearSel();
15694
15695         wxPyEndAllowThreads(__tstate);
15696         if (PyErr_Occurred()) SWIG_fail;
15697     }
15698     Py_INCREF(Py_None); resultobj = Py_None;
15699     return resultobj;
15700     fail:
15701     return NULL;
15702 }
15703
15704
15705 static PyObject *_wrap_Slider_GetSelEnd(PyObject *, PyObject *args, PyObject *kwargs) {
15706     PyObject *resultobj;
15707     wxSlider *arg1 = (wxSlider *) 0 ;
15708     int result;
15709     PyObject * obj0 = 0 ;
15710     char *kwnames[] = {
15711         (char *) "self", NULL
15712     };
15713
15714     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetSelEnd",kwnames,&obj0)) goto fail;
15715     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15716     if (SWIG_arg_fail(1)) SWIG_fail;
15717     {
15718         PyThreadState* __tstate = wxPyBeginAllowThreads();
15719         result = (int)((wxSlider const *)arg1)->GetSelEnd();
15720
15721         wxPyEndAllowThreads(__tstate);
15722         if (PyErr_Occurred()) SWIG_fail;
15723     }
15724     {
15725         resultobj = SWIG_From_int((int)(result));
15726     }
15727     return resultobj;
15728     fail:
15729     return NULL;
15730 }
15731
15732
15733 static PyObject *_wrap_Slider_GetSelStart(PyObject *, PyObject *args, PyObject *kwargs) {
15734     PyObject *resultobj;
15735     wxSlider *arg1 = (wxSlider *) 0 ;
15736     int result;
15737     PyObject * obj0 = 0 ;
15738     char *kwnames[] = {
15739         (char *) "self", NULL
15740     };
15741
15742     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Slider_GetSelStart",kwnames,&obj0)) goto fail;
15743     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15744     if (SWIG_arg_fail(1)) SWIG_fail;
15745     {
15746         PyThreadState* __tstate = wxPyBeginAllowThreads();
15747         result = (int)((wxSlider const *)arg1)->GetSelStart();
15748
15749         wxPyEndAllowThreads(__tstate);
15750         if (PyErr_Occurred()) SWIG_fail;
15751     }
15752     {
15753         resultobj = SWIG_From_int((int)(result));
15754     }
15755     return resultobj;
15756     fail:
15757     return NULL;
15758 }
15759
15760
15761 static PyObject *_wrap_Slider_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15762     PyObject *resultobj;
15763     wxSlider *arg1 = (wxSlider *) 0 ;
15764     int arg2 ;
15765     int arg3 ;
15766     PyObject * obj0 = 0 ;
15767     PyObject * obj1 = 0 ;
15768     PyObject * obj2 = 0 ;
15769     char *kwnames[] = {
15770         (char *) "self",(char *) "min",(char *) "max", NULL
15771     };
15772
15773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15774     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSlider, SWIG_POINTER_EXCEPTION | 0);
15775     if (SWIG_arg_fail(1)) SWIG_fail;
15776     {
15777         arg2 = (int)(SWIG_As_int(obj1));
15778         if (SWIG_arg_fail(2)) SWIG_fail;
15779     }
15780     {
15781         arg3 = (int)(SWIG_As_int(obj2));
15782         if (SWIG_arg_fail(3)) SWIG_fail;
15783     }
15784     {
15785         PyThreadState* __tstate = wxPyBeginAllowThreads();
15786         (arg1)->SetSelection(arg2,arg3);
15787
15788         wxPyEndAllowThreads(__tstate);
15789         if (PyErr_Occurred()) SWIG_fail;
15790     }
15791     Py_INCREF(Py_None); resultobj = Py_None;
15792     return resultobj;
15793     fail:
15794     return NULL;
15795 }
15796
15797
15798 static PyObject *_wrap_Slider_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
15799     PyObject *resultobj;
15800     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
15801     wxVisualAttributes result;
15802     PyObject * obj0 = 0 ;
15803     char *kwnames[] = {
15804         (char *) "variant", NULL
15805     };
15806
15807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Slider_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
15808     if (obj0) {
15809         {
15810             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
15811             if (SWIG_arg_fail(1)) SWIG_fail;
15812         }
15813     }
15814     {
15815         if (!wxPyCheckForApp()) SWIG_fail;
15816         PyThreadState* __tstate = wxPyBeginAllowThreads();
15817         result = wxSlider::GetClassDefaultAttributes((wxWindowVariant )arg1);
15818
15819         wxPyEndAllowThreads(__tstate);
15820         if (PyErr_Occurred()) SWIG_fail;
15821     }
15822     {
15823         wxVisualAttributes * resultptr;
15824         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
15825         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
15826     }
15827     return resultobj;
15828     fail:
15829     return NULL;
15830 }
15831
15832
15833 static PyObject * Slider_swigregister(PyObject *, PyObject *args) {
15834     PyObject *obj;
15835     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15836     SWIG_TypeClientData(SWIGTYPE_p_wxSlider, obj);
15837     Py_INCREF(obj);
15838     return Py_BuildValue((char *)"");
15839 }
15840 static int _wrap_ToggleButtonNameStr_set(PyObject *) {
15841     PyErr_SetString(PyExc_TypeError,"Variable ToggleButtonNameStr is read-only.");
15842     return 1;
15843 }
15844
15845
15846 static PyObject *_wrap_ToggleButtonNameStr_get(void) {
15847     PyObject *pyobj;
15848
15849     {
15850 #if wxUSE_UNICODE
15851         pyobj = PyUnicode_FromWideChar((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
15852 #else
15853         pyobj = PyString_FromStringAndSize((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
15854 #endif
15855     }
15856     return pyobj;
15857 }
15858
15859
15860 static PyObject *_wrap_new_ToggleButton(PyObject *, PyObject *args, PyObject *kwargs) {
15861     PyObject *resultobj;
15862     wxWindow *arg1 = (wxWindow *) 0 ;
15863     int arg2 = (int) -1 ;
15864     wxString const &arg3_defvalue = wxPyEmptyString ;
15865     wxString *arg3 = (wxString *) &arg3_defvalue ;
15866     wxPoint const &arg4_defvalue = wxDefaultPosition ;
15867     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
15868     wxSize const &arg5_defvalue = wxDefaultSize ;
15869     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
15870     long arg6 = (long) 0 ;
15871     wxValidator const &arg7_defvalue = wxDefaultValidator ;
15872     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
15873     wxString const &arg8_defvalue = wxPyToggleButtonNameStr ;
15874     wxString *arg8 = (wxString *) &arg8_defvalue ;
15875     wxToggleButton *result;
15876     bool temp3 = false ;
15877     wxPoint temp4 ;
15878     wxSize temp5 ;
15879     bool temp8 = false ;
15880     PyObject * obj0 = 0 ;
15881     PyObject * obj1 = 0 ;
15882     PyObject * obj2 = 0 ;
15883     PyObject * obj3 = 0 ;
15884     PyObject * obj4 = 0 ;
15885     PyObject * obj5 = 0 ;
15886     PyObject * obj6 = 0 ;
15887     PyObject * obj7 = 0 ;
15888     char *kwnames[] = {
15889         (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
15890     };
15891
15892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ToggleButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
15893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15894     if (SWIG_arg_fail(1)) SWIG_fail;
15895     if (obj1) {
15896         {
15897             arg2 = (int)(SWIG_As_int(obj1));
15898             if (SWIG_arg_fail(2)) SWIG_fail;
15899         }
15900     }
15901     if (obj2) {
15902         {
15903             arg3 = wxString_in_helper(obj2);
15904             if (arg3 == NULL) SWIG_fail;
15905             temp3 = true;
15906         }
15907     }
15908     if (obj3) {
15909         {
15910             arg4 = &temp4;
15911             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
15912         }
15913     }
15914     if (obj4) {
15915         {
15916             arg5 = &temp5;
15917             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
15918         }
15919     }
15920     if (obj5) {
15921         {
15922             arg6 = (long)(SWIG_As_long(obj5));
15923             if (SWIG_arg_fail(6)) SWIG_fail;
15924         }
15925     }
15926     if (obj6) {
15927         {
15928             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
15929             if (SWIG_arg_fail(7)) SWIG_fail;
15930             if (arg7 == NULL) {
15931                 SWIG_null_ref("wxValidator");
15932             }
15933             if (SWIG_arg_fail(7)) SWIG_fail;
15934         }
15935     }
15936     if (obj7) {
15937         {
15938             arg8 = wxString_in_helper(obj7);
15939             if (arg8 == NULL) SWIG_fail;
15940             temp8 = true;
15941         }
15942     }
15943     {
15944         if (!wxPyCheckForApp()) SWIG_fail;
15945         PyThreadState* __tstate = wxPyBeginAllowThreads();
15946         result = (wxToggleButton *)new wxToggleButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
15947
15948         wxPyEndAllowThreads(__tstate);
15949         if (PyErr_Occurred()) SWIG_fail;
15950     }
15951     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToggleButton, 1);
15952     {
15953         if (temp3)
15954         delete arg3;
15955     }
15956     {
15957         if (temp8)
15958         delete arg8;
15959     }
15960     return resultobj;
15961     fail:
15962     {
15963         if (temp3)
15964         delete arg3;
15965     }
15966     {
15967         if (temp8)
15968         delete arg8;
15969     }
15970     return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_new_PreToggleButton(PyObject *, PyObject *args, PyObject *kwargs) {
15975     PyObject *resultobj;
15976     wxToggleButton *result;
15977     char *kwnames[] = {
15978         NULL
15979     };
15980
15981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreToggleButton",kwnames)) goto fail;
15982     {
15983         if (!wxPyCheckForApp()) SWIG_fail;
15984         PyThreadState* __tstate = wxPyBeginAllowThreads();
15985         result = (wxToggleButton *)new wxToggleButton();
15986
15987         wxPyEndAllowThreads(__tstate);
15988         if (PyErr_Occurred()) SWIG_fail;
15989     }
15990     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToggleButton, 1);
15991     return resultobj;
15992     fail:
15993     return NULL;
15994 }
15995
15996
15997 static PyObject *_wrap_ToggleButton_Create(PyObject *, PyObject *args, PyObject *kwargs) {
15998     PyObject *resultobj;
15999     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16000     wxWindow *arg2 = (wxWindow *) 0 ;
16001     int arg3 = (int) -1 ;
16002     wxString const &arg4_defvalue = wxPyEmptyString ;
16003     wxString *arg4 = (wxString *) &arg4_defvalue ;
16004     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16005     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16006     wxSize const &arg6_defvalue = wxDefaultSize ;
16007     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16008     long arg7 = (long) 0 ;
16009     wxValidator const &arg8_defvalue = wxDefaultValidator ;
16010     wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
16011     wxString const &arg9_defvalue = wxPyToggleButtonNameStr ;
16012     wxString *arg9 = (wxString *) &arg9_defvalue ;
16013     bool result;
16014     bool temp4 = false ;
16015     wxPoint temp5 ;
16016     wxSize temp6 ;
16017     bool temp9 = false ;
16018     PyObject * obj0 = 0 ;
16019     PyObject * obj1 = 0 ;
16020     PyObject * obj2 = 0 ;
16021     PyObject * obj3 = 0 ;
16022     PyObject * obj4 = 0 ;
16023     PyObject * obj5 = 0 ;
16024     PyObject * obj6 = 0 ;
16025     PyObject * obj7 = 0 ;
16026     PyObject * obj8 = 0 ;
16027     char *kwnames[] = {
16028         (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
16029     };
16030
16031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ToggleButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
16032     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16033     if (SWIG_arg_fail(1)) SWIG_fail;
16034     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16035     if (SWIG_arg_fail(2)) SWIG_fail;
16036     if (obj2) {
16037         {
16038             arg3 = (int)(SWIG_As_int(obj2));
16039             if (SWIG_arg_fail(3)) SWIG_fail;
16040         }
16041     }
16042     if (obj3) {
16043         {
16044             arg4 = wxString_in_helper(obj3);
16045             if (arg4 == NULL) SWIG_fail;
16046             temp4 = true;
16047         }
16048     }
16049     if (obj4) {
16050         {
16051             arg5 = &temp5;
16052             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16053         }
16054     }
16055     if (obj5) {
16056         {
16057             arg6 = &temp6;
16058             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16059         }
16060     }
16061     if (obj6) {
16062         {
16063             arg7 = (long)(SWIG_As_long(obj6));
16064             if (SWIG_arg_fail(7)) SWIG_fail;
16065         }
16066     }
16067     if (obj7) {
16068         {
16069             SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
16070             if (SWIG_arg_fail(8)) SWIG_fail;
16071             if (arg8 == NULL) {
16072                 SWIG_null_ref("wxValidator");
16073             }
16074             if (SWIG_arg_fail(8)) SWIG_fail;
16075         }
16076     }
16077     if (obj8) {
16078         {
16079             arg9 = wxString_in_helper(obj8);
16080             if (arg9 == NULL) SWIG_fail;
16081             temp9 = true;
16082         }
16083     }
16084     {
16085         PyThreadState* __tstate = wxPyBeginAllowThreads();
16086         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
16087
16088         wxPyEndAllowThreads(__tstate);
16089         if (PyErr_Occurred()) SWIG_fail;
16090     }
16091     {
16092         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16093     }
16094     {
16095         if (temp4)
16096         delete arg4;
16097     }
16098     {
16099         if (temp9)
16100         delete arg9;
16101     }
16102     return resultobj;
16103     fail:
16104     {
16105         if (temp4)
16106         delete arg4;
16107     }
16108     {
16109         if (temp9)
16110         delete arg9;
16111     }
16112     return NULL;
16113 }
16114
16115
16116 static PyObject *_wrap_ToggleButton_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
16117     PyObject *resultobj;
16118     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16119     bool arg2 ;
16120     PyObject * obj0 = 0 ;
16121     PyObject * obj1 = 0 ;
16122     char *kwnames[] = {
16123         (char *) "self",(char *) "value", NULL
16124     };
16125
16126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToggleButton_SetValue",kwnames,&obj0,&obj1)) goto fail;
16127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16128     if (SWIG_arg_fail(1)) SWIG_fail;
16129     {
16130         arg2 = (bool)(SWIG_As_bool(obj1));
16131         if (SWIG_arg_fail(2)) SWIG_fail;
16132     }
16133     {
16134         PyThreadState* __tstate = wxPyBeginAllowThreads();
16135         (arg1)->SetValue(arg2);
16136
16137         wxPyEndAllowThreads(__tstate);
16138         if (PyErr_Occurred()) SWIG_fail;
16139     }
16140     Py_INCREF(Py_None); resultobj = Py_None;
16141     return resultobj;
16142     fail:
16143     return NULL;
16144 }
16145
16146
16147 static PyObject *_wrap_ToggleButton_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
16148     PyObject *resultobj;
16149     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16150     bool result;
16151     PyObject * obj0 = 0 ;
16152     char *kwnames[] = {
16153         (char *) "self", NULL
16154     };
16155
16156     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToggleButton_GetValue",kwnames,&obj0)) goto fail;
16157     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16158     if (SWIG_arg_fail(1)) SWIG_fail;
16159     {
16160         PyThreadState* __tstate = wxPyBeginAllowThreads();
16161         result = (bool)((wxToggleButton const *)arg1)->GetValue();
16162
16163         wxPyEndAllowThreads(__tstate);
16164         if (PyErr_Occurred()) SWIG_fail;
16165     }
16166     {
16167         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16168     }
16169     return resultobj;
16170     fail:
16171     return NULL;
16172 }
16173
16174
16175 static PyObject *_wrap_ToggleButton_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
16176     PyObject *resultobj;
16177     wxToggleButton *arg1 = (wxToggleButton *) 0 ;
16178     wxString *arg2 = 0 ;
16179     bool temp2 = false ;
16180     PyObject * obj0 = 0 ;
16181     PyObject * obj1 = 0 ;
16182     char *kwnames[] = {
16183         (char *) "self",(char *) "label", NULL
16184     };
16185
16186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToggleButton_SetLabel",kwnames,&obj0,&obj1)) goto fail;
16187     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToggleButton, SWIG_POINTER_EXCEPTION | 0);
16188     if (SWIG_arg_fail(1)) SWIG_fail;
16189     {
16190         arg2 = wxString_in_helper(obj1);
16191         if (arg2 == NULL) SWIG_fail;
16192         temp2 = true;
16193     }
16194     {
16195         PyThreadState* __tstate = wxPyBeginAllowThreads();
16196         (arg1)->SetLabel((wxString const &)*arg2);
16197
16198         wxPyEndAllowThreads(__tstate);
16199         if (PyErr_Occurred()) SWIG_fail;
16200     }
16201     Py_INCREF(Py_None); resultobj = Py_None;
16202     {
16203         if (temp2)
16204         delete arg2;
16205     }
16206     return resultobj;
16207     fail:
16208     {
16209         if (temp2)
16210         delete arg2;
16211     }
16212     return NULL;
16213 }
16214
16215
16216 static PyObject *_wrap_ToggleButton_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16217     PyObject *resultobj;
16218     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16219     wxVisualAttributes result;
16220     PyObject * obj0 = 0 ;
16221     char *kwnames[] = {
16222         (char *) "variant", NULL
16223     };
16224
16225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToggleButton_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16226     if (obj0) {
16227         {
16228             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
16229             if (SWIG_arg_fail(1)) SWIG_fail;
16230         }
16231     }
16232     {
16233         if (!wxPyCheckForApp()) SWIG_fail;
16234         PyThreadState* __tstate = wxPyBeginAllowThreads();
16235         result = wxToggleButton::GetClassDefaultAttributes((wxWindowVariant )arg1);
16236
16237         wxPyEndAllowThreads(__tstate);
16238         if (PyErr_Occurred()) SWIG_fail;
16239     }
16240     {
16241         wxVisualAttributes * resultptr;
16242         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
16243         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16244     }
16245     return resultobj;
16246     fail:
16247     return NULL;
16248 }
16249
16250
16251 static PyObject * ToggleButton_swigregister(PyObject *, PyObject *args) {
16252     PyObject *obj;
16253     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16254     SWIG_TypeClientData(SWIGTYPE_p_wxToggleButton, obj);
16255     Py_INCREF(obj);
16256     return Py_BuildValue((char *)"");
16257 }
16258 static int _wrap_NotebookNameStr_set(PyObject *) {
16259     PyErr_SetString(PyExc_TypeError,"Variable NotebookNameStr is read-only.");
16260     return 1;
16261 }
16262
16263
16264 static PyObject *_wrap_NotebookNameStr_get(void) {
16265     PyObject *pyobj;
16266
16267     {
16268 #if wxUSE_UNICODE
16269         pyobj = PyUnicode_FromWideChar((&wxPyNotebookNameStr)->c_str(), (&wxPyNotebookNameStr)->Len());
16270 #else
16271         pyobj = PyString_FromStringAndSize((&wxPyNotebookNameStr)->c_str(), (&wxPyNotebookNameStr)->Len());
16272 #endif
16273     }
16274     return pyobj;
16275 }
16276
16277
16278 static PyObject *_wrap_BookCtrlBase_GetPageCount(PyObject *, PyObject *args, PyObject *kwargs) {
16279     PyObject *resultobj;
16280     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16281     size_t result;
16282     PyObject * obj0 = 0 ;
16283     char *kwnames[] = {
16284         (char *) "self", NULL
16285     };
16286
16287     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetPageCount",kwnames,&obj0)) goto fail;
16288     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16289     if (SWIG_arg_fail(1)) SWIG_fail;
16290     {
16291         PyThreadState* __tstate = wxPyBeginAllowThreads();
16292         result = (size_t)((wxBookCtrlBase const *)arg1)->GetPageCount();
16293
16294         wxPyEndAllowThreads(__tstate);
16295         if (PyErr_Occurred()) SWIG_fail;
16296     }
16297     {
16298         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16299     }
16300     return resultobj;
16301     fail:
16302     return NULL;
16303 }
16304
16305
16306 static PyObject *_wrap_BookCtrlBase_GetPage(PyObject *, PyObject *args, PyObject *kwargs) {
16307     PyObject *resultobj;
16308     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16309     size_t arg2 ;
16310     wxWindow *result;
16311     PyObject * obj0 = 0 ;
16312     PyObject * obj1 = 0 ;
16313     char *kwnames[] = {
16314         (char *) "self",(char *) "n", NULL
16315     };
16316
16317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPage",kwnames,&obj0,&obj1)) goto fail;
16318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16319     if (SWIG_arg_fail(1)) SWIG_fail;
16320     {
16321         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16322         if (SWIG_arg_fail(2)) SWIG_fail;
16323     }
16324     {
16325         PyThreadState* __tstate = wxPyBeginAllowThreads();
16326         result = (wxWindow *)(arg1)->GetPage(arg2);
16327
16328         wxPyEndAllowThreads(__tstate);
16329         if (PyErr_Occurred()) SWIG_fail;
16330     }
16331     {
16332         resultobj = wxPyMake_wxObject(result, 0);
16333     }
16334     return resultobj;
16335     fail:
16336     return NULL;
16337 }
16338
16339
16340 static PyObject *_wrap_BookCtrlBase_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
16341     PyObject *resultobj;
16342     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16343     wxWindow *result;
16344     PyObject * obj0 = 0 ;
16345     char *kwnames[] = {
16346         (char *) "self", NULL
16347     };
16348
16349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetCurrentPage",kwnames,&obj0)) goto fail;
16350     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16351     if (SWIG_arg_fail(1)) SWIG_fail;
16352     {
16353         PyThreadState* __tstate = wxPyBeginAllowThreads();
16354         result = (wxWindow *)((wxBookCtrlBase const *)arg1)->GetCurrentPage();
16355
16356         wxPyEndAllowThreads(__tstate);
16357         if (PyErr_Occurred()) SWIG_fail;
16358     }
16359     {
16360         resultobj = wxPyMake_wxObject(result, 0);
16361     }
16362     return resultobj;
16363     fail:
16364     return NULL;
16365 }
16366
16367
16368 static PyObject *_wrap_BookCtrlBase_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16369     PyObject *resultobj;
16370     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16371     int result;
16372     PyObject * obj0 = 0 ;
16373     char *kwnames[] = {
16374         (char *) "self", NULL
16375     };
16376
16377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetSelection",kwnames,&obj0)) goto fail;
16378     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16379     if (SWIG_arg_fail(1)) SWIG_fail;
16380     {
16381         PyThreadState* __tstate = wxPyBeginAllowThreads();
16382         result = (int)((wxBookCtrlBase const *)arg1)->GetSelection();
16383
16384         wxPyEndAllowThreads(__tstate);
16385         if (PyErr_Occurred()) SWIG_fail;
16386     }
16387     {
16388         resultobj = SWIG_From_int((int)(result));
16389     }
16390     return resultobj;
16391     fail:
16392     return NULL;
16393 }
16394
16395
16396 static PyObject *_wrap_BookCtrlBase_SetPageText(PyObject *, PyObject *args, PyObject *kwargs) {
16397     PyObject *resultobj;
16398     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16399     size_t arg2 ;
16400     wxString *arg3 = 0 ;
16401     bool result;
16402     bool temp3 = false ;
16403     PyObject * obj0 = 0 ;
16404     PyObject * obj1 = 0 ;
16405     PyObject * obj2 = 0 ;
16406     char *kwnames[] = {
16407         (char *) "self",(char *) "n",(char *) "strText", NULL
16408     };
16409
16410     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BookCtrlBase_SetPageText",kwnames,&obj0,&obj1,&obj2)) goto fail;
16411     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16412     if (SWIG_arg_fail(1)) SWIG_fail;
16413     {
16414         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16415         if (SWIG_arg_fail(2)) SWIG_fail;
16416     }
16417     {
16418         arg3 = wxString_in_helper(obj2);
16419         if (arg3 == NULL) SWIG_fail;
16420         temp3 = true;
16421     }
16422     {
16423         PyThreadState* __tstate = wxPyBeginAllowThreads();
16424         result = (bool)(arg1)->SetPageText(arg2,(wxString const &)*arg3);
16425
16426         wxPyEndAllowThreads(__tstate);
16427         if (PyErr_Occurred()) SWIG_fail;
16428     }
16429     {
16430         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16431     }
16432     {
16433         if (temp3)
16434         delete arg3;
16435     }
16436     return resultobj;
16437     fail:
16438     {
16439         if (temp3)
16440         delete arg3;
16441     }
16442     return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_BookCtrlBase_GetPageText(PyObject *, PyObject *args, PyObject *kwargs) {
16447     PyObject *resultobj;
16448     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16449     size_t arg2 ;
16450     wxString result;
16451     PyObject * obj0 = 0 ;
16452     PyObject * obj1 = 0 ;
16453     char *kwnames[] = {
16454         (char *) "self",(char *) "n", NULL
16455     };
16456
16457     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPageText",kwnames,&obj0,&obj1)) goto fail;
16458     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16459     if (SWIG_arg_fail(1)) SWIG_fail;
16460     {
16461         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16462         if (SWIG_arg_fail(2)) SWIG_fail;
16463     }
16464     {
16465         PyThreadState* __tstate = wxPyBeginAllowThreads();
16466         result = ((wxBookCtrlBase const *)arg1)->GetPageText(arg2);
16467
16468         wxPyEndAllowThreads(__tstate);
16469         if (PyErr_Occurred()) SWIG_fail;
16470     }
16471     {
16472 #if wxUSE_UNICODE
16473         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16474 #else
16475         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16476 #endif
16477     }
16478     return resultobj;
16479     fail:
16480     return NULL;
16481 }
16482
16483
16484 static PyObject *_wrap_BookCtrlBase_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16485     PyObject *resultobj;
16486     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16487     wxImageList *arg2 = (wxImageList *) 0 ;
16488     PyObject * obj0 = 0 ;
16489     PyObject * obj1 = 0 ;
16490     char *kwnames[] = {
16491         (char *) "self",(char *) "imageList", NULL
16492     };
16493
16494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetImageList",kwnames,&obj0,&obj1)) goto fail;
16495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16496     if (SWIG_arg_fail(1)) SWIG_fail;
16497     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
16498     if (SWIG_arg_fail(2)) SWIG_fail;
16499     {
16500         PyThreadState* __tstate = wxPyBeginAllowThreads();
16501         (arg1)->SetImageList(arg2);
16502
16503         wxPyEndAllowThreads(__tstate);
16504         if (PyErr_Occurred()) SWIG_fail;
16505     }
16506     Py_INCREF(Py_None); resultobj = Py_None;
16507     return resultobj;
16508     fail:
16509     return NULL;
16510 }
16511
16512
16513 static PyObject *_wrap_BookCtrlBase_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16514     PyObject *resultobj;
16515     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16516     wxImageList *arg2 = (wxImageList *) 0 ;
16517     PyObject * obj0 = 0 ;
16518     PyObject * obj1 = 0 ;
16519     char *kwnames[] = {
16520         (char *) "self",(char *) "imageList", NULL
16521     };
16522
16523     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_AssignImageList",kwnames,&obj0,&obj1)) goto fail;
16524     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16525     if (SWIG_arg_fail(1)) SWIG_fail;
16526     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16527     if (SWIG_arg_fail(2)) SWIG_fail;
16528     {
16529         PyThreadState* __tstate = wxPyBeginAllowThreads();
16530         (arg1)->AssignImageList(arg2);
16531
16532         wxPyEndAllowThreads(__tstate);
16533         if (PyErr_Occurred()) SWIG_fail;
16534     }
16535     Py_INCREF(Py_None); resultobj = Py_None;
16536     return resultobj;
16537     fail:
16538     return NULL;
16539 }
16540
16541
16542 static PyObject *_wrap_BookCtrlBase_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
16543     PyObject *resultobj;
16544     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16545     wxImageList *result;
16546     PyObject * obj0 = 0 ;
16547     char *kwnames[] = {
16548         (char *) "self", NULL
16549     };
16550
16551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_GetImageList",kwnames,&obj0)) goto fail;
16552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16553     if (SWIG_arg_fail(1)) SWIG_fail;
16554     {
16555         PyThreadState* __tstate = wxPyBeginAllowThreads();
16556         result = (wxImageList *)((wxBookCtrlBase const *)arg1)->GetImageList();
16557
16558         wxPyEndAllowThreads(__tstate);
16559         if (PyErr_Occurred()) SWIG_fail;
16560     }
16561     {
16562         resultobj = wxPyMake_wxObject(result, 0);
16563     }
16564     return resultobj;
16565     fail:
16566     return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_BookCtrlBase_GetPageImage(PyObject *, PyObject *args, PyObject *kwargs) {
16571     PyObject *resultobj;
16572     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16573     size_t arg2 ;
16574     int result;
16575     PyObject * obj0 = 0 ;
16576     PyObject * obj1 = 0 ;
16577     char *kwnames[] = {
16578         (char *) "self",(char *) "n", NULL
16579     };
16580
16581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_GetPageImage",kwnames,&obj0,&obj1)) goto fail;
16582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16583     if (SWIG_arg_fail(1)) SWIG_fail;
16584     {
16585         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16586         if (SWIG_arg_fail(2)) SWIG_fail;
16587     }
16588     {
16589         PyThreadState* __tstate = wxPyBeginAllowThreads();
16590         result = (int)((wxBookCtrlBase const *)arg1)->GetPageImage(arg2);
16591
16592         wxPyEndAllowThreads(__tstate);
16593         if (PyErr_Occurred()) SWIG_fail;
16594     }
16595     {
16596         resultobj = SWIG_From_int((int)(result));
16597     }
16598     return resultobj;
16599     fail:
16600     return NULL;
16601 }
16602
16603
16604 static PyObject *_wrap_BookCtrlBase_SetPageImage(PyObject *, PyObject *args, PyObject *kwargs) {
16605     PyObject *resultobj;
16606     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16607     size_t arg2 ;
16608     int arg3 ;
16609     bool result;
16610     PyObject * obj0 = 0 ;
16611     PyObject * obj1 = 0 ;
16612     PyObject * obj2 = 0 ;
16613     char *kwnames[] = {
16614         (char *) "self",(char *) "n",(char *) "imageId", NULL
16615     };
16616
16617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BookCtrlBase_SetPageImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
16618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16619     if (SWIG_arg_fail(1)) SWIG_fail;
16620     {
16621         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16622         if (SWIG_arg_fail(2)) SWIG_fail;
16623     }
16624     {
16625         arg3 = (int)(SWIG_As_int(obj2));
16626         if (SWIG_arg_fail(3)) SWIG_fail;
16627     }
16628     {
16629         PyThreadState* __tstate = wxPyBeginAllowThreads();
16630         result = (bool)(arg1)->SetPageImage(arg2,arg3);
16631
16632         wxPyEndAllowThreads(__tstate);
16633         if (PyErr_Occurred()) SWIG_fail;
16634     }
16635     {
16636         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16637     }
16638     return resultobj;
16639     fail:
16640     return NULL;
16641 }
16642
16643
16644 static PyObject *_wrap_BookCtrlBase_SetPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
16645     PyObject *resultobj;
16646     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16647     wxSize *arg2 = 0 ;
16648     wxSize temp2 ;
16649     PyObject * obj0 = 0 ;
16650     PyObject * obj1 = 0 ;
16651     char *kwnames[] = {
16652         (char *) "self",(char *) "size", NULL
16653     };
16654
16655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetPageSize",kwnames,&obj0,&obj1)) goto fail;
16656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16657     if (SWIG_arg_fail(1)) SWIG_fail;
16658     {
16659         arg2 = &temp2;
16660         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16661     }
16662     {
16663         PyThreadState* __tstate = wxPyBeginAllowThreads();
16664         (arg1)->SetPageSize((wxSize const &)*arg2);
16665
16666         wxPyEndAllowThreads(__tstate);
16667         if (PyErr_Occurred()) SWIG_fail;
16668     }
16669     Py_INCREF(Py_None); resultobj = Py_None;
16670     return resultobj;
16671     fail:
16672     return NULL;
16673 }
16674
16675
16676 static PyObject *_wrap_BookCtrlBase_CalcSizeFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
16677     PyObject *resultobj;
16678     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16679     wxSize *arg2 = 0 ;
16680     wxSize result;
16681     wxSize temp2 ;
16682     PyObject * obj0 = 0 ;
16683     PyObject * obj1 = 0 ;
16684     char *kwnames[] = {
16685         (char *) "self",(char *) "sizePage", NULL
16686     };
16687
16688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_CalcSizeFromPage",kwnames,&obj0,&obj1)) goto fail;
16689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16690     if (SWIG_arg_fail(1)) SWIG_fail;
16691     {
16692         arg2 = &temp2;
16693         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16694     }
16695     {
16696         PyThreadState* __tstate = wxPyBeginAllowThreads();
16697         result = ((wxBookCtrlBase const *)arg1)->CalcSizeFromPage((wxSize const &)*arg2);
16698
16699         wxPyEndAllowThreads(__tstate);
16700         if (PyErr_Occurred()) SWIG_fail;
16701     }
16702     {
16703         wxSize * resultptr;
16704         resultptr = new wxSize((wxSize &)(result));
16705         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16706     }
16707     return resultobj;
16708     fail:
16709     return NULL;
16710 }
16711
16712
16713 static PyObject *_wrap_BookCtrlBase_DeletePage(PyObject *, PyObject *args, PyObject *kwargs) {
16714     PyObject *resultobj;
16715     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16716     size_t arg2 ;
16717     bool result;
16718     PyObject * obj0 = 0 ;
16719     PyObject * obj1 = 0 ;
16720     char *kwnames[] = {
16721         (char *) "self",(char *) "n", NULL
16722     };
16723
16724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_DeletePage",kwnames,&obj0,&obj1)) goto fail;
16725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16726     if (SWIG_arg_fail(1)) SWIG_fail;
16727     {
16728         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16729         if (SWIG_arg_fail(2)) SWIG_fail;
16730     }
16731     {
16732         PyThreadState* __tstate = wxPyBeginAllowThreads();
16733         result = (bool)(arg1)->DeletePage(arg2);
16734
16735         wxPyEndAllowThreads(__tstate);
16736         if (PyErr_Occurred()) SWIG_fail;
16737     }
16738     {
16739         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16740     }
16741     return resultobj;
16742     fail:
16743     return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_BookCtrlBase_RemovePage(PyObject *, PyObject *args, PyObject *kwargs) {
16748     PyObject *resultobj;
16749     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16750     size_t arg2 ;
16751     bool result;
16752     PyObject * obj0 = 0 ;
16753     PyObject * obj1 = 0 ;
16754     char *kwnames[] = {
16755         (char *) "self",(char *) "n", NULL
16756     };
16757
16758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_RemovePage",kwnames,&obj0,&obj1)) goto fail;
16759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16760     if (SWIG_arg_fail(1)) SWIG_fail;
16761     {
16762         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16763         if (SWIG_arg_fail(2)) SWIG_fail;
16764     }
16765     {
16766         PyThreadState* __tstate = wxPyBeginAllowThreads();
16767         result = (bool)(arg1)->RemovePage(arg2);
16768
16769         wxPyEndAllowThreads(__tstate);
16770         if (PyErr_Occurred()) SWIG_fail;
16771     }
16772     {
16773         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16774     }
16775     return resultobj;
16776     fail:
16777     return NULL;
16778 }
16779
16780
16781 static PyObject *_wrap_BookCtrlBase_DeleteAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
16782     PyObject *resultobj;
16783     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16784     bool result;
16785     PyObject * obj0 = 0 ;
16786     char *kwnames[] = {
16787         (char *) "self", NULL
16788     };
16789
16790     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBase_DeleteAllPages",kwnames,&obj0)) goto fail;
16791     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16792     if (SWIG_arg_fail(1)) SWIG_fail;
16793     {
16794         PyThreadState* __tstate = wxPyBeginAllowThreads();
16795         result = (bool)(arg1)->DeleteAllPages();
16796
16797         wxPyEndAllowThreads(__tstate);
16798         if (PyErr_Occurred()) SWIG_fail;
16799     }
16800     {
16801         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16802     }
16803     return resultobj;
16804     fail:
16805     return NULL;
16806 }
16807
16808
16809 static PyObject *_wrap_BookCtrlBase_AddPage(PyObject *, PyObject *args, PyObject *kwargs) {
16810     PyObject *resultobj;
16811     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16812     wxWindow *arg2 = (wxWindow *) 0 ;
16813     wxString *arg3 = 0 ;
16814     bool arg4 = (bool) false ;
16815     int arg5 = (int) -1 ;
16816     bool result;
16817     bool temp3 = false ;
16818     PyObject * obj0 = 0 ;
16819     PyObject * obj1 = 0 ;
16820     PyObject * obj2 = 0 ;
16821     PyObject * obj3 = 0 ;
16822     PyObject * obj4 = 0 ;
16823     char *kwnames[] = {
16824         (char *) "self",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL
16825     };
16826
16827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:BookCtrlBase_AddPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16829     if (SWIG_arg_fail(1)) SWIG_fail;
16830     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16831     if (SWIG_arg_fail(2)) SWIG_fail;
16832     {
16833         arg3 = wxString_in_helper(obj2);
16834         if (arg3 == NULL) SWIG_fail;
16835         temp3 = true;
16836     }
16837     if (obj3) {
16838         {
16839             arg4 = (bool)(SWIG_As_bool(obj3));
16840             if (SWIG_arg_fail(4)) SWIG_fail;
16841         }
16842     }
16843     if (obj4) {
16844         {
16845             arg5 = (int)(SWIG_As_int(obj4));
16846             if (SWIG_arg_fail(5)) SWIG_fail;
16847         }
16848     }
16849     {
16850         PyThreadState* __tstate = wxPyBeginAllowThreads();
16851         result = (bool)(arg1)->AddPage(arg2,(wxString const &)*arg3,arg4,arg5);
16852
16853         wxPyEndAllowThreads(__tstate);
16854         if (PyErr_Occurred()) SWIG_fail;
16855     }
16856     {
16857         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16858     }
16859     {
16860         if (temp3)
16861         delete arg3;
16862     }
16863     return resultobj;
16864     fail:
16865     {
16866         if (temp3)
16867         delete arg3;
16868     }
16869     return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_BookCtrlBase_InsertPage(PyObject *, PyObject *args, PyObject *kwargs) {
16874     PyObject *resultobj;
16875     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16876     size_t arg2 ;
16877     wxWindow *arg3 = (wxWindow *) 0 ;
16878     wxString *arg4 = 0 ;
16879     bool arg5 = (bool) false ;
16880     int arg6 = (int) -1 ;
16881     bool result;
16882     bool temp4 = false ;
16883     PyObject * obj0 = 0 ;
16884     PyObject * obj1 = 0 ;
16885     PyObject * obj2 = 0 ;
16886     PyObject * obj3 = 0 ;
16887     PyObject * obj4 = 0 ;
16888     PyObject * obj5 = 0 ;
16889     char *kwnames[] = {
16890         (char *) "self",(char *) "n",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL
16891     };
16892
16893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:BookCtrlBase_InsertPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
16894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16895     if (SWIG_arg_fail(1)) SWIG_fail;
16896     {
16897         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16898         if (SWIG_arg_fail(2)) SWIG_fail;
16899     }
16900     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16901     if (SWIG_arg_fail(3)) SWIG_fail;
16902     {
16903         arg4 = wxString_in_helper(obj3);
16904         if (arg4 == NULL) SWIG_fail;
16905         temp4 = true;
16906     }
16907     if (obj4) {
16908         {
16909             arg5 = (bool)(SWIG_As_bool(obj4));
16910             if (SWIG_arg_fail(5)) SWIG_fail;
16911         }
16912     }
16913     if (obj5) {
16914         {
16915             arg6 = (int)(SWIG_As_int(obj5));
16916             if (SWIG_arg_fail(6)) SWIG_fail;
16917         }
16918     }
16919     {
16920         PyThreadState* __tstate = wxPyBeginAllowThreads();
16921         result = (bool)(arg1)->InsertPage(arg2,arg3,(wxString const &)*arg4,arg5,arg6);
16922
16923         wxPyEndAllowThreads(__tstate);
16924         if (PyErr_Occurred()) SWIG_fail;
16925     }
16926     {
16927         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16928     }
16929     {
16930         if (temp4)
16931         delete arg4;
16932     }
16933     return resultobj;
16934     fail:
16935     {
16936         if (temp4)
16937         delete arg4;
16938     }
16939     return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_BookCtrlBase_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16944     PyObject *resultobj;
16945     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16946     size_t arg2 ;
16947     int result;
16948     PyObject * obj0 = 0 ;
16949     PyObject * obj1 = 0 ;
16950     char *kwnames[] = {
16951         (char *) "self",(char *) "n", NULL
16952     };
16953
16954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBase_SetSelection",kwnames,&obj0,&obj1)) goto fail;
16955     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16956     if (SWIG_arg_fail(1)) SWIG_fail;
16957     {
16958         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
16959         if (SWIG_arg_fail(2)) SWIG_fail;
16960     }
16961     {
16962         PyThreadState* __tstate = wxPyBeginAllowThreads();
16963         result = (int)(arg1)->SetSelection(arg2);
16964
16965         wxPyEndAllowThreads(__tstate);
16966         if (PyErr_Occurred()) SWIG_fail;
16967     }
16968     {
16969         resultobj = SWIG_From_int((int)(result));
16970     }
16971     return resultobj;
16972     fail:
16973     return NULL;
16974 }
16975
16976
16977 static PyObject *_wrap_BookCtrlBase_AdvanceSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16978     PyObject *resultobj;
16979     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
16980     bool arg2 = (bool) true ;
16981     PyObject * obj0 = 0 ;
16982     PyObject * obj1 = 0 ;
16983     char *kwnames[] = {
16984         (char *) "self",(char *) "forward", NULL
16985     };
16986
16987     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:BookCtrlBase_AdvanceSelection",kwnames,&obj0,&obj1)) goto fail;
16988     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
16989     if (SWIG_arg_fail(1)) SWIG_fail;
16990     if (obj1) {
16991         {
16992             arg2 = (bool)(SWIG_As_bool(obj1));
16993             if (SWIG_arg_fail(2)) SWIG_fail;
16994         }
16995     }
16996     {
16997         PyThreadState* __tstate = wxPyBeginAllowThreads();
16998         (arg1)->AdvanceSelection(arg2);
16999
17000         wxPyEndAllowThreads(__tstate);
17001         if (PyErr_Occurred()) SWIG_fail;
17002     }
17003     Py_INCREF(Py_None); resultobj = Py_None;
17004     return resultobj;
17005     fail:
17006     return NULL;
17007 }
17008
17009
17010 static PyObject *_wrap_BookCtrlBase_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
17011     PyObject *resultobj;
17012     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
17013     wxVisualAttributes result;
17014     PyObject * obj0 = 0 ;
17015     char *kwnames[] = {
17016         (char *) "variant", NULL
17017     };
17018
17019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BookCtrlBase_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
17020     if (obj0) {
17021         {
17022             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
17023             if (SWIG_arg_fail(1)) SWIG_fail;
17024         }
17025     }
17026     {
17027         if (!wxPyCheckForApp()) SWIG_fail;
17028         PyThreadState* __tstate = wxPyBeginAllowThreads();
17029         result = wxBookCtrlBase::GetClassDefaultAttributes((wxWindowVariant )arg1);
17030
17031         wxPyEndAllowThreads(__tstate);
17032         if (PyErr_Occurred()) SWIG_fail;
17033     }
17034     {
17035         wxVisualAttributes * resultptr;
17036         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
17037         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
17038     }
17039     return resultobj;
17040     fail:
17041     return NULL;
17042 }
17043
17044
17045 static PyObject * BookCtrlBase_swigregister(PyObject *, PyObject *args) {
17046     PyObject *obj;
17047     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17048     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlBase, obj);
17049     Py_INCREF(obj);
17050     return Py_BuildValue((char *)"");
17051 }
17052 static PyObject *_wrap_new_BookCtrlBaseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17053     PyObject *resultobj;
17054     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17055     int arg2 = (int) 0 ;
17056     int arg3 = (int) -1 ;
17057     int arg4 = (int) -1 ;
17058     wxBookCtrlBaseEvent *result;
17059     PyObject * obj0 = 0 ;
17060     PyObject * obj1 = 0 ;
17061     PyObject * obj2 = 0 ;
17062     PyObject * obj3 = 0 ;
17063     char *kwnames[] = {
17064         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17065     };
17066
17067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_BookCtrlBaseEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17068     if (obj0) {
17069         {
17070             arg1 = (wxEventType)(SWIG_As_int(obj0));
17071             if (SWIG_arg_fail(1)) SWIG_fail;
17072         }
17073     }
17074     if (obj1) {
17075         {
17076             arg2 = (int)(SWIG_As_int(obj1));
17077             if (SWIG_arg_fail(2)) SWIG_fail;
17078         }
17079     }
17080     if (obj2) {
17081         {
17082             arg3 = (int)(SWIG_As_int(obj2));
17083             if (SWIG_arg_fail(3)) SWIG_fail;
17084         }
17085     }
17086     if (obj3) {
17087         {
17088             arg4 = (int)(SWIG_As_int(obj3));
17089             if (SWIG_arg_fail(4)) SWIG_fail;
17090         }
17091     }
17092     {
17093         PyThreadState* __tstate = wxPyBeginAllowThreads();
17094         result = (wxBookCtrlBaseEvent *)new wxBookCtrlBaseEvent(arg1,arg2,arg3,arg4);
17095
17096         wxPyEndAllowThreads(__tstate);
17097         if (PyErr_Occurred()) SWIG_fail;
17098     }
17099     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlBaseEvent, 1);
17100     return resultobj;
17101     fail:
17102     return NULL;
17103 }
17104
17105
17106 static PyObject *_wrap_BookCtrlBaseEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17107     PyObject *resultobj;
17108     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17109     int result;
17110     PyObject * obj0 = 0 ;
17111     char *kwnames[] = {
17112         (char *) "self", NULL
17113     };
17114
17115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBaseEvent_GetSelection",kwnames,&obj0)) goto fail;
17116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17117     if (SWIG_arg_fail(1)) SWIG_fail;
17118     {
17119         PyThreadState* __tstate = wxPyBeginAllowThreads();
17120         result = (int)((wxBookCtrlBaseEvent const *)arg1)->GetSelection();
17121
17122         wxPyEndAllowThreads(__tstate);
17123         if (PyErr_Occurred()) SWIG_fail;
17124     }
17125     {
17126         resultobj = SWIG_From_int((int)(result));
17127     }
17128     return resultobj;
17129     fail:
17130     return NULL;
17131 }
17132
17133
17134 static PyObject *_wrap_BookCtrlBaseEvent_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17135     PyObject *resultobj;
17136     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17137     int arg2 ;
17138     PyObject * obj0 = 0 ;
17139     PyObject * obj1 = 0 ;
17140     char *kwnames[] = {
17141         (char *) "self",(char *) "nSel", NULL
17142     };
17143
17144     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBaseEvent_SetSelection",kwnames,&obj0,&obj1)) goto fail;
17145     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17146     if (SWIG_arg_fail(1)) SWIG_fail;
17147     {
17148         arg2 = (int)(SWIG_As_int(obj1));
17149         if (SWIG_arg_fail(2)) SWIG_fail;
17150     }
17151     {
17152         PyThreadState* __tstate = wxPyBeginAllowThreads();
17153         (arg1)->SetSelection(arg2);
17154
17155         wxPyEndAllowThreads(__tstate);
17156         if (PyErr_Occurred()) SWIG_fail;
17157     }
17158     Py_INCREF(Py_None); resultobj = Py_None;
17159     return resultobj;
17160     fail:
17161     return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_BookCtrlBaseEvent_GetOldSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17166     PyObject *resultobj;
17167     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17168     int result;
17169     PyObject * obj0 = 0 ;
17170     char *kwnames[] = {
17171         (char *) "self", NULL
17172     };
17173
17174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlBaseEvent_GetOldSelection",kwnames,&obj0)) goto fail;
17175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17176     if (SWIG_arg_fail(1)) SWIG_fail;
17177     {
17178         PyThreadState* __tstate = wxPyBeginAllowThreads();
17179         result = (int)((wxBookCtrlBaseEvent const *)arg1)->GetOldSelection();
17180
17181         wxPyEndAllowThreads(__tstate);
17182         if (PyErr_Occurred()) SWIG_fail;
17183     }
17184     {
17185         resultobj = SWIG_From_int((int)(result));
17186     }
17187     return resultobj;
17188     fail:
17189     return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_BookCtrlBaseEvent_SetOldSelection(PyObject *, PyObject *args, PyObject *kwargs) {
17194     PyObject *resultobj;
17195     wxBookCtrlBaseEvent *arg1 = (wxBookCtrlBaseEvent *) 0 ;
17196     int arg2 ;
17197     PyObject * obj0 = 0 ;
17198     PyObject * obj1 = 0 ;
17199     char *kwnames[] = {
17200         (char *) "self",(char *) "nOldSel", NULL
17201     };
17202
17203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BookCtrlBaseEvent_SetOldSelection",kwnames,&obj0,&obj1)) goto fail;
17204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBaseEvent, SWIG_POINTER_EXCEPTION | 0);
17205     if (SWIG_arg_fail(1)) SWIG_fail;
17206     {
17207         arg2 = (int)(SWIG_As_int(obj1));
17208         if (SWIG_arg_fail(2)) SWIG_fail;
17209     }
17210     {
17211         PyThreadState* __tstate = wxPyBeginAllowThreads();
17212         (arg1)->SetOldSelection(arg2);
17213
17214         wxPyEndAllowThreads(__tstate);
17215         if (PyErr_Occurred()) SWIG_fail;
17216     }
17217     Py_INCREF(Py_None); resultobj = Py_None;
17218     return resultobj;
17219     fail:
17220     return NULL;
17221 }
17222
17223
17224 static PyObject * BookCtrlBaseEvent_swigregister(PyObject *, PyObject *args) {
17225     PyObject *obj;
17226     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17227     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlBaseEvent, obj);
17228     Py_INCREF(obj);
17229     return Py_BuildValue((char *)"");
17230 }
17231 static PyObject *_wrap_new_Notebook(PyObject *, PyObject *args, PyObject *kwargs) {
17232     PyObject *resultobj;
17233     wxWindow *arg1 = (wxWindow *) 0 ;
17234     int arg2 = (int) -1 ;
17235     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17236     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17237     wxSize const &arg4_defvalue = wxDefaultSize ;
17238     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17239     long arg5 = (long) 0 ;
17240     wxString const &arg6_defvalue = wxPyNotebookNameStr ;
17241     wxString *arg6 = (wxString *) &arg6_defvalue ;
17242     wxNotebook *result;
17243     wxPoint temp3 ;
17244     wxSize temp4 ;
17245     bool temp6 = false ;
17246     PyObject * obj0 = 0 ;
17247     PyObject * obj1 = 0 ;
17248     PyObject * obj2 = 0 ;
17249     PyObject * obj3 = 0 ;
17250     PyObject * obj4 = 0 ;
17251     PyObject * obj5 = 0 ;
17252     char *kwnames[] = {
17253         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17254     };
17255
17256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Notebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17257     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17258     if (SWIG_arg_fail(1)) SWIG_fail;
17259     if (obj1) {
17260         {
17261             arg2 = (int)(SWIG_As_int(obj1));
17262             if (SWIG_arg_fail(2)) SWIG_fail;
17263         }
17264     }
17265     if (obj2) {
17266         {
17267             arg3 = &temp3;
17268             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17269         }
17270     }
17271     if (obj3) {
17272         {
17273             arg4 = &temp4;
17274             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17275         }
17276     }
17277     if (obj4) {
17278         {
17279             arg5 = (long)(SWIG_As_long(obj4));
17280             if (SWIG_arg_fail(5)) SWIG_fail;
17281         }
17282     }
17283     if (obj5) {
17284         {
17285             arg6 = wxString_in_helper(obj5);
17286             if (arg6 == NULL) SWIG_fail;
17287             temp6 = true;
17288         }
17289     }
17290     {
17291         if (!wxPyCheckForApp()) SWIG_fail;
17292         PyThreadState* __tstate = wxPyBeginAllowThreads();
17293         result = (wxNotebook *)new wxNotebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17294
17295         wxPyEndAllowThreads(__tstate);
17296         if (PyErr_Occurred()) SWIG_fail;
17297     }
17298     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebook, 1);
17299     {
17300         if (temp6)
17301         delete arg6;
17302     }
17303     return resultobj;
17304     fail:
17305     {
17306         if (temp6)
17307         delete arg6;
17308     }
17309     return NULL;
17310 }
17311
17312
17313 static PyObject *_wrap_new_PreNotebook(PyObject *, PyObject *args, PyObject *kwargs) {
17314     PyObject *resultobj;
17315     wxNotebook *result;
17316     char *kwnames[] = {
17317         NULL
17318     };
17319
17320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreNotebook",kwnames)) goto fail;
17321     {
17322         if (!wxPyCheckForApp()) SWIG_fail;
17323         PyThreadState* __tstate = wxPyBeginAllowThreads();
17324         result = (wxNotebook *)new wxNotebook();
17325
17326         wxPyEndAllowThreads(__tstate);
17327         if (PyErr_Occurred()) SWIG_fail;
17328     }
17329     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebook, 1);
17330     return resultobj;
17331     fail:
17332     return NULL;
17333 }
17334
17335
17336 static PyObject *_wrap_Notebook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17337     PyObject *resultobj;
17338     wxNotebook *arg1 = (wxNotebook *) 0 ;
17339     wxWindow *arg2 = (wxWindow *) 0 ;
17340     int arg3 = (int) -1 ;
17341     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17342     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17343     wxSize const &arg5_defvalue = wxDefaultSize ;
17344     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17345     long arg6 = (long) 0 ;
17346     wxString const &arg7_defvalue = wxPyNotebookNameStr ;
17347     wxString *arg7 = (wxString *) &arg7_defvalue ;
17348     bool result;
17349     wxPoint temp4 ;
17350     wxSize temp5 ;
17351     bool temp7 = false ;
17352     PyObject * obj0 = 0 ;
17353     PyObject * obj1 = 0 ;
17354     PyObject * obj2 = 0 ;
17355     PyObject * obj3 = 0 ;
17356     PyObject * obj4 = 0 ;
17357     PyObject * obj5 = 0 ;
17358     PyObject * obj6 = 0 ;
17359     char *kwnames[] = {
17360         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17361     };
17362
17363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Notebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17364     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17365     if (SWIG_arg_fail(1)) SWIG_fail;
17366     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17367     if (SWIG_arg_fail(2)) SWIG_fail;
17368     if (obj2) {
17369         {
17370             arg3 = (int)(SWIG_As_int(obj2));
17371             if (SWIG_arg_fail(3)) SWIG_fail;
17372         }
17373     }
17374     if (obj3) {
17375         {
17376             arg4 = &temp4;
17377             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17378         }
17379     }
17380     if (obj4) {
17381         {
17382             arg5 = &temp5;
17383             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17384         }
17385     }
17386     if (obj5) {
17387         {
17388             arg6 = (long)(SWIG_As_long(obj5));
17389             if (SWIG_arg_fail(6)) SWIG_fail;
17390         }
17391     }
17392     if (obj6) {
17393         {
17394             arg7 = wxString_in_helper(obj6);
17395             if (arg7 == NULL) SWIG_fail;
17396             temp7 = true;
17397         }
17398     }
17399     {
17400         PyThreadState* __tstate = wxPyBeginAllowThreads();
17401         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17402
17403         wxPyEndAllowThreads(__tstate);
17404         if (PyErr_Occurred()) SWIG_fail;
17405     }
17406     {
17407         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17408     }
17409     {
17410         if (temp7)
17411         delete arg7;
17412     }
17413     return resultobj;
17414     fail:
17415     {
17416         if (temp7)
17417         delete arg7;
17418     }
17419     return NULL;
17420 }
17421
17422
17423 static PyObject *_wrap_Notebook_GetRowCount(PyObject *, PyObject *args, PyObject *kwargs) {
17424     PyObject *resultobj;
17425     wxNotebook *arg1 = (wxNotebook *) 0 ;
17426     int result;
17427     PyObject * obj0 = 0 ;
17428     char *kwnames[] = {
17429         (char *) "self", NULL
17430     };
17431
17432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Notebook_GetRowCount",kwnames,&obj0)) goto fail;
17433     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17434     if (SWIG_arg_fail(1)) SWIG_fail;
17435     {
17436         PyThreadState* __tstate = wxPyBeginAllowThreads();
17437         result = (int)((wxNotebook const *)arg1)->GetRowCount();
17438
17439         wxPyEndAllowThreads(__tstate);
17440         if (PyErr_Occurred()) SWIG_fail;
17441     }
17442     {
17443         resultobj = SWIG_From_int((int)(result));
17444     }
17445     return resultobj;
17446     fail:
17447     return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_Notebook_SetPadding(PyObject *, PyObject *args, PyObject *kwargs) {
17452     PyObject *resultobj;
17453     wxNotebook *arg1 = (wxNotebook *) 0 ;
17454     wxSize *arg2 = 0 ;
17455     wxSize temp2 ;
17456     PyObject * obj0 = 0 ;
17457     PyObject * obj1 = 0 ;
17458     char *kwnames[] = {
17459         (char *) "self",(char *) "padding", NULL
17460     };
17461
17462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetPadding",kwnames,&obj0,&obj1)) goto fail;
17463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17464     if (SWIG_arg_fail(1)) SWIG_fail;
17465     {
17466         arg2 = &temp2;
17467         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17468     }
17469     {
17470         PyThreadState* __tstate = wxPyBeginAllowThreads();
17471         (arg1)->SetPadding((wxSize const &)*arg2);
17472
17473         wxPyEndAllowThreads(__tstate);
17474         if (PyErr_Occurred()) SWIG_fail;
17475     }
17476     Py_INCREF(Py_None); resultobj = Py_None;
17477     return resultobj;
17478     fail:
17479     return NULL;
17480 }
17481
17482
17483 static PyObject *_wrap_Notebook_SetTabSize(PyObject *, PyObject *args, PyObject *kwargs) {
17484     PyObject *resultobj;
17485     wxNotebook *arg1 = (wxNotebook *) 0 ;
17486     wxSize *arg2 = 0 ;
17487     wxSize temp2 ;
17488     PyObject * obj0 = 0 ;
17489     PyObject * obj1 = 0 ;
17490     char *kwnames[] = {
17491         (char *) "self",(char *) "sz", NULL
17492     };
17493
17494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetTabSize",kwnames,&obj0,&obj1)) goto fail;
17495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17496     if (SWIG_arg_fail(1)) SWIG_fail;
17497     {
17498         arg2 = &temp2;
17499         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17500     }
17501     {
17502         PyThreadState* __tstate = wxPyBeginAllowThreads();
17503         (arg1)->SetTabSize((wxSize const &)*arg2);
17504
17505         wxPyEndAllowThreads(__tstate);
17506         if (PyErr_Occurred()) SWIG_fail;
17507     }
17508     Py_INCREF(Py_None); resultobj = Py_None;
17509     return resultobj;
17510     fail:
17511     return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_Notebook_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
17516     PyObject *resultobj;
17517     wxNotebook *arg1 = (wxNotebook *) 0 ;
17518     wxPoint *arg2 = 0 ;
17519     long *arg3 = (long *) 0 ;
17520     int result;
17521     wxPoint temp2 ;
17522     long temp3 ;
17523     int res3 = 0 ;
17524     PyObject * obj0 = 0 ;
17525     PyObject * obj1 = 0 ;
17526     char *kwnames[] = {
17527         (char *) "self",(char *) "pt", NULL
17528     };
17529
17530     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_HitTest",kwnames,&obj0,&obj1)) goto fail;
17532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17533     if (SWIG_arg_fail(1)) SWIG_fail;
17534     {
17535         arg2 = &temp2;
17536         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17537     }
17538     {
17539         PyThreadState* __tstate = wxPyBeginAllowThreads();
17540         result = (int)((wxNotebook const *)arg1)->HitTest((wxPoint const &)*arg2,arg3);
17541
17542         wxPyEndAllowThreads(__tstate);
17543         if (PyErr_Occurred()) SWIG_fail;
17544     }
17545     {
17546         resultobj = SWIG_From_int((int)(result));
17547     }
17548     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17549     SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17550     return resultobj;
17551     fail:
17552     return NULL;
17553 }
17554
17555
17556 static PyObject *_wrap_Notebook_CalcSizeFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
17557     PyObject *resultobj;
17558     wxNotebook *arg1 = (wxNotebook *) 0 ;
17559     wxSize *arg2 = 0 ;
17560     wxSize result;
17561     wxSize temp2 ;
17562     PyObject * obj0 = 0 ;
17563     PyObject * obj1 = 0 ;
17564     char *kwnames[] = {
17565         (char *) "self",(char *) "sizePage", NULL
17566     };
17567
17568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_CalcSizeFromPage",kwnames,&obj0,&obj1)) goto fail;
17569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17570     if (SWIG_arg_fail(1)) SWIG_fail;
17571     {
17572         arg2 = &temp2;
17573         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17574     }
17575     {
17576         PyThreadState* __tstate = wxPyBeginAllowThreads();
17577         result = ((wxNotebook const *)arg1)->CalcSizeFromPage((wxSize const &)*arg2);
17578
17579         wxPyEndAllowThreads(__tstate);
17580         if (PyErr_Occurred()) SWIG_fail;
17581     }
17582     {
17583         wxSize * resultptr;
17584         resultptr = new wxSize((wxSize &)(result));
17585         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17586     }
17587     return resultobj;
17588     fail:
17589     return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_Notebook_GetThemeBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
17594     PyObject *resultobj;
17595     wxNotebook *arg1 = (wxNotebook *) 0 ;
17596     wxColour result;
17597     PyObject * obj0 = 0 ;
17598     char *kwnames[] = {
17599         (char *) "self", NULL
17600     };
17601
17602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Notebook_GetThemeBackgroundColour",kwnames,&obj0)) goto fail;
17603     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
17604     if (SWIG_arg_fail(1)) SWIG_fail;
17605     {
17606         PyThreadState* __tstate = wxPyBeginAllowThreads();
17607         result = ((wxNotebook const *)arg1)->GetThemeBackgroundColour();
17608
17609         wxPyEndAllowThreads(__tstate);
17610         if (PyErr_Occurred()) SWIG_fail;
17611     }
17612     {
17613         wxColour * resultptr;
17614         resultptr = new wxColour((wxColour &)(result));
17615         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
17616     }
17617     return resultobj;
17618     fail:
17619     return NULL;
17620 }
17621
17622
17623 static PyObject *_wrap_Notebook_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
17624     PyObject *resultobj;
17625     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
17626     wxVisualAttributes result;
17627     PyObject * obj0 = 0 ;
17628     char *kwnames[] = {
17629         (char *) "variant", NULL
17630     };
17631
17632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Notebook_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
17633     if (obj0) {
17634         {
17635             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
17636             if (SWIG_arg_fail(1)) SWIG_fail;
17637         }
17638     }
17639     {
17640         if (!wxPyCheckForApp()) SWIG_fail;
17641         PyThreadState* __tstate = wxPyBeginAllowThreads();
17642         result = wxNotebook::GetClassDefaultAttributes((wxWindowVariant )arg1);
17643
17644         wxPyEndAllowThreads(__tstate);
17645         if (PyErr_Occurred()) SWIG_fail;
17646     }
17647     {
17648         wxVisualAttributes * resultptr;
17649         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
17650         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
17651     }
17652     return resultobj;
17653     fail:
17654     return NULL;
17655 }
17656
17657
17658 static PyObject * Notebook_swigregister(PyObject *, PyObject *args) {
17659     PyObject *obj;
17660     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17661     SWIG_TypeClientData(SWIGTYPE_p_wxNotebook, obj);
17662     Py_INCREF(obj);
17663     return Py_BuildValue((char *)"");
17664 }
17665 static PyObject *_wrap_new_NotebookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17666     PyObject *resultobj;
17667     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17668     int arg2 = (int) 0 ;
17669     int arg3 = (int) -1 ;
17670     int arg4 = (int) -1 ;
17671     wxNotebookEvent *result;
17672     PyObject * obj0 = 0 ;
17673     PyObject * obj1 = 0 ;
17674     PyObject * obj2 = 0 ;
17675     PyObject * obj3 = 0 ;
17676     char *kwnames[] = {
17677         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17678     };
17679
17680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_NotebookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17681     if (obj0) {
17682         {
17683             arg1 = (wxEventType)(SWIG_As_int(obj0));
17684             if (SWIG_arg_fail(1)) SWIG_fail;
17685         }
17686     }
17687     if (obj1) {
17688         {
17689             arg2 = (int)(SWIG_As_int(obj1));
17690             if (SWIG_arg_fail(2)) SWIG_fail;
17691         }
17692     }
17693     if (obj2) {
17694         {
17695             arg3 = (int)(SWIG_As_int(obj2));
17696             if (SWIG_arg_fail(3)) SWIG_fail;
17697         }
17698     }
17699     if (obj3) {
17700         {
17701             arg4 = (int)(SWIG_As_int(obj3));
17702             if (SWIG_arg_fail(4)) SWIG_fail;
17703         }
17704     }
17705     {
17706         PyThreadState* __tstate = wxPyBeginAllowThreads();
17707         result = (wxNotebookEvent *)new wxNotebookEvent(arg1,arg2,arg3,arg4);
17708
17709         wxPyEndAllowThreads(__tstate);
17710         if (PyErr_Occurred()) SWIG_fail;
17711     }
17712     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebookEvent, 1);
17713     return resultobj;
17714     fail:
17715     return NULL;
17716 }
17717
17718
17719 static PyObject * NotebookEvent_swigregister(PyObject *, PyObject *args) {
17720     PyObject *obj;
17721     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17722     SWIG_TypeClientData(SWIGTYPE_p_wxNotebookEvent, obj);
17723     Py_INCREF(obj);
17724     return Py_BuildValue((char *)"");
17725 }
17726 static PyObject *_wrap_new_Listbook(PyObject *, PyObject *args, PyObject *kwargs) {
17727     PyObject *resultobj;
17728     wxWindow *arg1 = (wxWindow *) 0 ;
17729     int arg2 = (int) -1 ;
17730     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17731     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17732     wxSize const &arg4_defvalue = wxDefaultSize ;
17733     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17734     long arg5 = (long) 0 ;
17735     wxString const &arg6_defvalue = wxPyEmptyString ;
17736     wxString *arg6 = (wxString *) &arg6_defvalue ;
17737     wxListbook *result;
17738     wxPoint temp3 ;
17739     wxSize temp4 ;
17740     bool temp6 = false ;
17741     PyObject * obj0 = 0 ;
17742     PyObject * obj1 = 0 ;
17743     PyObject * obj2 = 0 ;
17744     PyObject * obj3 = 0 ;
17745     PyObject * obj4 = 0 ;
17746     PyObject * obj5 = 0 ;
17747     char *kwnames[] = {
17748         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17749     };
17750
17751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Listbook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17752     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17753     if (SWIG_arg_fail(1)) SWIG_fail;
17754     if (obj1) {
17755         {
17756             arg2 = (int)(SWIG_As_int(obj1));
17757             if (SWIG_arg_fail(2)) SWIG_fail;
17758         }
17759     }
17760     if (obj2) {
17761         {
17762             arg3 = &temp3;
17763             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17764         }
17765     }
17766     if (obj3) {
17767         {
17768             arg4 = &temp4;
17769             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17770         }
17771     }
17772     if (obj4) {
17773         {
17774             arg5 = (long)(SWIG_As_long(obj4));
17775             if (SWIG_arg_fail(5)) SWIG_fail;
17776         }
17777     }
17778     if (obj5) {
17779         {
17780             arg6 = wxString_in_helper(obj5);
17781             if (arg6 == NULL) SWIG_fail;
17782             temp6 = true;
17783         }
17784     }
17785     {
17786         if (!wxPyCheckForApp()) SWIG_fail;
17787         PyThreadState* __tstate = wxPyBeginAllowThreads();
17788         result = (wxListbook *)new wxListbook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17789
17790         wxPyEndAllowThreads(__tstate);
17791         if (PyErr_Occurred()) SWIG_fail;
17792     }
17793     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbook, 1);
17794     {
17795         if (temp6)
17796         delete arg6;
17797     }
17798     return resultobj;
17799     fail:
17800     {
17801         if (temp6)
17802         delete arg6;
17803     }
17804     return NULL;
17805 }
17806
17807
17808 static PyObject *_wrap_new_PreListbook(PyObject *, PyObject *args, PyObject *kwargs) {
17809     PyObject *resultobj;
17810     wxListbook *result;
17811     char *kwnames[] = {
17812         NULL
17813     };
17814
17815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListbook",kwnames)) goto fail;
17816     {
17817         if (!wxPyCheckForApp()) SWIG_fail;
17818         PyThreadState* __tstate = wxPyBeginAllowThreads();
17819         result = (wxListbook *)new wxListbook();
17820
17821         wxPyEndAllowThreads(__tstate);
17822         if (PyErr_Occurred()) SWIG_fail;
17823     }
17824     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbook, 1);
17825     return resultobj;
17826     fail:
17827     return NULL;
17828 }
17829
17830
17831 static PyObject *_wrap_Listbook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17832     PyObject *resultobj;
17833     wxListbook *arg1 = (wxListbook *) 0 ;
17834     wxWindow *arg2 = (wxWindow *) 0 ;
17835     int arg3 = (int) -1 ;
17836     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17837     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17838     wxSize const &arg5_defvalue = wxDefaultSize ;
17839     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17840     long arg6 = (long) 0 ;
17841     wxString const &arg7_defvalue = wxPyEmptyString ;
17842     wxString *arg7 = (wxString *) &arg7_defvalue ;
17843     bool result;
17844     wxPoint temp4 ;
17845     wxSize temp5 ;
17846     bool temp7 = false ;
17847     PyObject * obj0 = 0 ;
17848     PyObject * obj1 = 0 ;
17849     PyObject * obj2 = 0 ;
17850     PyObject * obj3 = 0 ;
17851     PyObject * obj4 = 0 ;
17852     PyObject * obj5 = 0 ;
17853     PyObject * obj6 = 0 ;
17854     char *kwnames[] = {
17855         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17856     };
17857
17858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Listbook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17860     if (SWIG_arg_fail(1)) SWIG_fail;
17861     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17862     if (SWIG_arg_fail(2)) SWIG_fail;
17863     if (obj2) {
17864         {
17865             arg3 = (int)(SWIG_As_int(obj2));
17866             if (SWIG_arg_fail(3)) SWIG_fail;
17867         }
17868     }
17869     if (obj3) {
17870         {
17871             arg4 = &temp4;
17872             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17873         }
17874     }
17875     if (obj4) {
17876         {
17877             arg5 = &temp5;
17878             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17879         }
17880     }
17881     if (obj5) {
17882         {
17883             arg6 = (long)(SWIG_As_long(obj5));
17884             if (SWIG_arg_fail(6)) SWIG_fail;
17885         }
17886     }
17887     if (obj6) {
17888         {
17889             arg7 = wxString_in_helper(obj6);
17890             if (arg7 == NULL) SWIG_fail;
17891             temp7 = true;
17892         }
17893     }
17894     {
17895         PyThreadState* __tstate = wxPyBeginAllowThreads();
17896         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17897
17898         wxPyEndAllowThreads(__tstate);
17899         if (PyErr_Occurred()) SWIG_fail;
17900     }
17901     {
17902         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17903     }
17904     {
17905         if (temp7)
17906         delete arg7;
17907     }
17908     return resultobj;
17909     fail:
17910     {
17911         if (temp7)
17912         delete arg7;
17913     }
17914     return NULL;
17915 }
17916
17917
17918 static PyObject *_wrap_Listbook_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
17919     PyObject *resultobj;
17920     wxListbook *arg1 = (wxListbook *) 0 ;
17921     bool result;
17922     PyObject * obj0 = 0 ;
17923     char *kwnames[] = {
17924         (char *) "self", NULL
17925     };
17926
17927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Listbook_IsVertical",kwnames,&obj0)) goto fail;
17928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17929     if (SWIG_arg_fail(1)) SWIG_fail;
17930     {
17931         PyThreadState* __tstate = wxPyBeginAllowThreads();
17932         result = (bool)((wxListbook const *)arg1)->IsVertical();
17933
17934         wxPyEndAllowThreads(__tstate);
17935         if (PyErr_Occurred()) SWIG_fail;
17936     }
17937     {
17938         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17939     }
17940     return resultobj;
17941     fail:
17942     return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_Listbook_GetListView(PyObject *, PyObject *args, PyObject *kwargs) {
17947     PyObject *resultobj;
17948     wxListbook *arg1 = (wxListbook *) 0 ;
17949     wxListView *result;
17950     PyObject * obj0 = 0 ;
17951     char *kwnames[] = {
17952         (char *) "self", NULL
17953     };
17954
17955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Listbook_GetListView",kwnames,&obj0)) goto fail;
17956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListbook, SWIG_POINTER_EXCEPTION | 0);
17957     if (SWIG_arg_fail(1)) SWIG_fail;
17958     {
17959         PyThreadState* __tstate = wxPyBeginAllowThreads();
17960         result = (wxListView *)(arg1)->GetListView();
17961
17962         wxPyEndAllowThreads(__tstate);
17963         if (PyErr_Occurred()) SWIG_fail;
17964     }
17965     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 0);
17966     return resultobj;
17967     fail:
17968     return NULL;
17969 }
17970
17971
17972 static PyObject * Listbook_swigregister(PyObject *, PyObject *args) {
17973     PyObject *obj;
17974     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17975     SWIG_TypeClientData(SWIGTYPE_p_wxListbook, obj);
17976     Py_INCREF(obj);
17977     return Py_BuildValue((char *)"");
17978 }
17979 static PyObject *_wrap_new_ListbookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17980     PyObject *resultobj;
17981     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17982     int arg2 = (int) 0 ;
17983     int arg3 = (int) -1 ;
17984     int arg4 = (int) -1 ;
17985     wxListbookEvent *result;
17986     PyObject * obj0 = 0 ;
17987     PyObject * obj1 = 0 ;
17988     PyObject * obj2 = 0 ;
17989     PyObject * obj3 = 0 ;
17990     char *kwnames[] = {
17991         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
17992     };
17993
17994     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ListbookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17995     if (obj0) {
17996         {
17997             arg1 = (wxEventType)(SWIG_As_int(obj0));
17998             if (SWIG_arg_fail(1)) SWIG_fail;
17999         }
18000     }
18001     if (obj1) {
18002         {
18003             arg2 = (int)(SWIG_As_int(obj1));
18004             if (SWIG_arg_fail(2)) SWIG_fail;
18005         }
18006     }
18007     if (obj2) {
18008         {
18009             arg3 = (int)(SWIG_As_int(obj2));
18010             if (SWIG_arg_fail(3)) SWIG_fail;
18011         }
18012     }
18013     if (obj3) {
18014         {
18015             arg4 = (int)(SWIG_As_int(obj3));
18016             if (SWIG_arg_fail(4)) SWIG_fail;
18017         }
18018     }
18019     {
18020         PyThreadState* __tstate = wxPyBeginAllowThreads();
18021         result = (wxListbookEvent *)new wxListbookEvent(arg1,arg2,arg3,arg4);
18022
18023         wxPyEndAllowThreads(__tstate);
18024         if (PyErr_Occurred()) SWIG_fail;
18025     }
18026     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListbookEvent, 1);
18027     return resultobj;
18028     fail:
18029     return NULL;
18030 }
18031
18032
18033 static PyObject * ListbookEvent_swigregister(PyObject *, PyObject *args) {
18034     PyObject *obj;
18035     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18036     SWIG_TypeClientData(SWIGTYPE_p_wxListbookEvent, obj);
18037     Py_INCREF(obj);
18038     return Py_BuildValue((char *)"");
18039 }
18040 static PyObject *_wrap_new_Choicebook(PyObject *, PyObject *args, PyObject *kwargs) {
18041     PyObject *resultobj;
18042     wxWindow *arg1 = (wxWindow *) 0 ;
18043     int arg2 ;
18044     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18045     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18046     wxSize const &arg4_defvalue = wxDefaultSize ;
18047     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18048     long arg5 = (long) 0 ;
18049     wxString const &arg6_defvalue = wxPyEmptyString ;
18050     wxString *arg6 = (wxString *) &arg6_defvalue ;
18051     wxChoicebook *result;
18052     wxPoint temp3 ;
18053     wxSize temp4 ;
18054     bool temp6 = false ;
18055     PyObject * obj0 = 0 ;
18056     PyObject * obj1 = 0 ;
18057     PyObject * obj2 = 0 ;
18058     PyObject * obj3 = 0 ;
18059     PyObject * obj4 = 0 ;
18060     PyObject * obj5 = 0 ;
18061     char *kwnames[] = {
18062         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18063     };
18064
18065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_Choicebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18067     if (SWIG_arg_fail(1)) SWIG_fail;
18068     {
18069         arg2 = (int)(SWIG_As_int(obj1));
18070         if (SWIG_arg_fail(2)) SWIG_fail;
18071     }
18072     if (obj2) {
18073         {
18074             arg3 = &temp3;
18075             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18076         }
18077     }
18078     if (obj3) {
18079         {
18080             arg4 = &temp4;
18081             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18082         }
18083     }
18084     if (obj4) {
18085         {
18086             arg5 = (long)(SWIG_As_long(obj4));
18087             if (SWIG_arg_fail(5)) SWIG_fail;
18088         }
18089     }
18090     if (obj5) {
18091         {
18092             arg6 = wxString_in_helper(obj5);
18093             if (arg6 == NULL) SWIG_fail;
18094             temp6 = true;
18095         }
18096     }
18097     {
18098         if (!wxPyCheckForApp()) SWIG_fail;
18099         PyThreadState* __tstate = wxPyBeginAllowThreads();
18100         result = (wxChoicebook *)new wxChoicebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18101
18102         wxPyEndAllowThreads(__tstate);
18103         if (PyErr_Occurred()) SWIG_fail;
18104     }
18105     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebook, 1);
18106     {
18107         if (temp6)
18108         delete arg6;
18109     }
18110     return resultobj;
18111     fail:
18112     {
18113         if (temp6)
18114         delete arg6;
18115     }
18116     return NULL;
18117 }
18118
18119
18120 static PyObject *_wrap_new_PreChoicebook(PyObject *, PyObject *args, PyObject *kwargs) {
18121     PyObject *resultobj;
18122     wxChoicebook *result;
18123     char *kwnames[] = {
18124         NULL
18125     };
18126
18127     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreChoicebook",kwnames)) goto fail;
18128     {
18129         if (!wxPyCheckForApp()) SWIG_fail;
18130         PyThreadState* __tstate = wxPyBeginAllowThreads();
18131         result = (wxChoicebook *)new wxChoicebook();
18132
18133         wxPyEndAllowThreads(__tstate);
18134         if (PyErr_Occurred()) SWIG_fail;
18135     }
18136     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebook, 1);
18137     return resultobj;
18138     fail:
18139     return NULL;
18140 }
18141
18142
18143 static PyObject *_wrap_Choicebook_Create(PyObject *, PyObject *args, PyObject *kwargs) {
18144     PyObject *resultobj;
18145     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18146     wxWindow *arg2 = (wxWindow *) 0 ;
18147     int arg3 ;
18148     wxPoint const &arg4_defvalue = wxDefaultPosition ;
18149     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
18150     wxSize const &arg5_defvalue = wxDefaultSize ;
18151     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
18152     long arg6 = (long) 0 ;
18153     wxString const &arg7_defvalue = wxPyEmptyString ;
18154     wxString *arg7 = (wxString *) &arg7_defvalue ;
18155     bool result;
18156     wxPoint temp4 ;
18157     wxSize temp5 ;
18158     bool temp7 = false ;
18159     PyObject * obj0 = 0 ;
18160     PyObject * obj1 = 0 ;
18161     PyObject * obj2 = 0 ;
18162     PyObject * obj3 = 0 ;
18163     PyObject * obj4 = 0 ;
18164     PyObject * obj5 = 0 ;
18165     PyObject * obj6 = 0 ;
18166     char *kwnames[] = {
18167         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18168     };
18169
18170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Choicebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18171     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18172     if (SWIG_arg_fail(1)) SWIG_fail;
18173     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18174     if (SWIG_arg_fail(2)) SWIG_fail;
18175     {
18176         arg3 = (int)(SWIG_As_int(obj2));
18177         if (SWIG_arg_fail(3)) SWIG_fail;
18178     }
18179     if (obj3) {
18180         {
18181             arg4 = &temp4;
18182             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
18183         }
18184     }
18185     if (obj4) {
18186         {
18187             arg5 = &temp5;
18188             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
18189         }
18190     }
18191     if (obj5) {
18192         {
18193             arg6 = (long)(SWIG_As_long(obj5));
18194             if (SWIG_arg_fail(6)) SWIG_fail;
18195         }
18196     }
18197     if (obj6) {
18198         {
18199             arg7 = wxString_in_helper(obj6);
18200             if (arg7 == NULL) SWIG_fail;
18201             temp7 = true;
18202         }
18203     }
18204     {
18205         PyThreadState* __tstate = wxPyBeginAllowThreads();
18206         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
18207
18208         wxPyEndAllowThreads(__tstate);
18209         if (PyErr_Occurred()) SWIG_fail;
18210     }
18211     {
18212         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18213     }
18214     {
18215         if (temp7)
18216         delete arg7;
18217     }
18218     return resultobj;
18219     fail:
18220     {
18221         if (temp7)
18222         delete arg7;
18223     }
18224     return NULL;
18225 }
18226
18227
18228 static PyObject *_wrap_Choicebook_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
18229     PyObject *resultobj;
18230     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18231     bool result;
18232     PyObject * obj0 = 0 ;
18233     char *kwnames[] = {
18234         (char *) "self", NULL
18235     };
18236
18237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Choicebook_IsVertical",kwnames,&obj0)) goto fail;
18238     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18239     if (SWIG_arg_fail(1)) SWIG_fail;
18240     {
18241         PyThreadState* __tstate = wxPyBeginAllowThreads();
18242         result = (bool)((wxChoicebook const *)arg1)->IsVertical();
18243
18244         wxPyEndAllowThreads(__tstate);
18245         if (PyErr_Occurred()) SWIG_fail;
18246     }
18247     {
18248         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18249     }
18250     return resultobj;
18251     fail:
18252     return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_Choicebook_DeleteAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
18257     PyObject *resultobj;
18258     wxChoicebook *arg1 = (wxChoicebook *) 0 ;
18259     bool result;
18260     PyObject * obj0 = 0 ;
18261     char *kwnames[] = {
18262         (char *) "self", NULL
18263     };
18264
18265     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Choicebook_DeleteAllPages",kwnames,&obj0)) goto fail;
18266     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChoicebook, SWIG_POINTER_EXCEPTION | 0);
18267     if (SWIG_arg_fail(1)) SWIG_fail;
18268     {
18269         PyThreadState* __tstate = wxPyBeginAllowThreads();
18270         result = (bool)(arg1)->DeleteAllPages();
18271
18272         wxPyEndAllowThreads(__tstate);
18273         if (PyErr_Occurred()) SWIG_fail;
18274     }
18275     {
18276         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18277     }
18278     return resultobj;
18279     fail:
18280     return NULL;
18281 }
18282
18283
18284 static PyObject * Choicebook_swigregister(PyObject *, PyObject *args) {
18285     PyObject *obj;
18286     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18287     SWIG_TypeClientData(SWIGTYPE_p_wxChoicebook, obj);
18288     Py_INCREF(obj);
18289     return Py_BuildValue((char *)"");
18290 }
18291 static PyObject *_wrap_new_ChoicebookEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18292     PyObject *resultobj;
18293     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18294     int arg2 = (int) 0 ;
18295     int arg3 = (int) -1 ;
18296     int arg4 = (int) -1 ;
18297     wxChoicebookEvent *result;
18298     PyObject * obj0 = 0 ;
18299     PyObject * obj1 = 0 ;
18300     PyObject * obj2 = 0 ;
18301     PyObject * obj3 = 0 ;
18302     char *kwnames[] = {
18303         (char *) "commandType",(char *) "id",(char *) "nSel",(char *) "nOldSel", NULL
18304     };
18305
18306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ChoicebookEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18307     if (obj0) {
18308         {
18309             arg1 = (wxEventType)(SWIG_As_int(obj0));
18310             if (SWIG_arg_fail(1)) SWIG_fail;
18311         }
18312     }
18313     if (obj1) {
18314         {
18315             arg2 = (int)(SWIG_As_int(obj1));
18316             if (SWIG_arg_fail(2)) SWIG_fail;
18317         }
18318     }
18319     if (obj2) {
18320         {
18321             arg3 = (int)(SWIG_As_int(obj2));
18322             if (SWIG_arg_fail(3)) SWIG_fail;
18323         }
18324     }
18325     if (obj3) {
18326         {
18327             arg4 = (int)(SWIG_As_int(obj3));
18328             if (SWIG_arg_fail(4)) SWIG_fail;
18329         }
18330     }
18331     {
18332         PyThreadState* __tstate = wxPyBeginAllowThreads();
18333         result = (wxChoicebookEvent *)new wxChoicebookEvent(arg1,arg2,arg3,arg4);
18334
18335         wxPyEndAllowThreads(__tstate);
18336         if (PyErr_Occurred()) SWIG_fail;
18337     }
18338     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChoicebookEvent, 1);
18339     return resultobj;
18340     fail:
18341     return NULL;
18342 }
18343
18344
18345 static PyObject * ChoicebookEvent_swigregister(PyObject *, PyObject *args) {
18346     PyObject *obj;
18347     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18348     SWIG_TypeClientData(SWIGTYPE_p_wxChoicebookEvent, obj);
18349     Py_INCREF(obj);
18350     return Py_BuildValue((char *)"");
18351 }
18352 static PyObject *_wrap_new_BookCtrlSizer(PyObject *, PyObject *args, PyObject *kwargs) {
18353     PyObject *resultobj;
18354     wxBookCtrlBase *arg1 = (wxBookCtrlBase *) 0 ;
18355     wxBookCtrlSizer *result;
18356     PyObject * obj0 = 0 ;
18357     char *kwnames[] = {
18358         (char *) "nb", NULL
18359     };
18360
18361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BookCtrlSizer",kwnames,&obj0)) goto fail;
18362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlBase, SWIG_POINTER_EXCEPTION | 0);
18363     if (SWIG_arg_fail(1)) SWIG_fail;
18364     {
18365         PyThreadState* __tstate = wxPyBeginAllowThreads();
18366         result = (wxBookCtrlSizer *)new wxBookCtrlSizer(arg1);
18367
18368         wxPyEndAllowThreads(__tstate);
18369         if (PyErr_Occurred()) SWIG_fail;
18370     }
18371     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlSizer, 1);
18372     return resultobj;
18373     fail:
18374     return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_BookCtrlSizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
18379     PyObject *resultobj;
18380     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18381     PyObject * obj0 = 0 ;
18382     char *kwnames[] = {
18383         (char *) "self", NULL
18384     };
18385
18386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_RecalcSizes",kwnames,&obj0)) goto fail;
18387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18388     if (SWIG_arg_fail(1)) SWIG_fail;
18389     {
18390         PyThreadState* __tstate = wxPyBeginAllowThreads();
18391         (arg1)->RecalcSizes();
18392
18393         wxPyEndAllowThreads(__tstate);
18394         if (PyErr_Occurred()) SWIG_fail;
18395     }
18396     Py_INCREF(Py_None); resultobj = Py_None;
18397     return resultobj;
18398     fail:
18399     return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_BookCtrlSizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
18404     PyObject *resultobj;
18405     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18406     wxSize result;
18407     PyObject * obj0 = 0 ;
18408     char *kwnames[] = {
18409         (char *) "self", NULL
18410     };
18411
18412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_CalcMin",kwnames,&obj0)) goto fail;
18413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18414     if (SWIG_arg_fail(1)) SWIG_fail;
18415     {
18416         PyThreadState* __tstate = wxPyBeginAllowThreads();
18417         result = (arg1)->CalcMin();
18418
18419         wxPyEndAllowThreads(__tstate);
18420         if (PyErr_Occurred()) SWIG_fail;
18421     }
18422     {
18423         wxSize * resultptr;
18424         resultptr = new wxSize((wxSize &)(result));
18425         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18426     }
18427     return resultobj;
18428     fail:
18429     return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_BookCtrlSizer_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18434     PyObject *resultobj;
18435     wxBookCtrlSizer *arg1 = (wxBookCtrlSizer *) 0 ;
18436     wxBookCtrlBase *result;
18437     PyObject * obj0 = 0 ;
18438     char *kwnames[] = {
18439         (char *) "self", NULL
18440     };
18441
18442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BookCtrlSizer_GetControl",kwnames,&obj0)) goto fail;
18443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBookCtrlSizer, SWIG_POINTER_EXCEPTION | 0);
18444     if (SWIG_arg_fail(1)) SWIG_fail;
18445     {
18446         PyThreadState* __tstate = wxPyBeginAllowThreads();
18447         result = (wxBookCtrlBase *)(arg1)->GetControl();
18448
18449         wxPyEndAllowThreads(__tstate);
18450         if (PyErr_Occurred()) SWIG_fail;
18451     }
18452     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBookCtrlBase, 0);
18453     return resultobj;
18454     fail:
18455     return NULL;
18456 }
18457
18458
18459 static PyObject * BookCtrlSizer_swigregister(PyObject *, PyObject *args) {
18460     PyObject *obj;
18461     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18462     SWIG_TypeClientData(SWIGTYPE_p_wxBookCtrlSizer, obj);
18463     Py_INCREF(obj);
18464     return Py_BuildValue((char *)"");
18465 }
18466 static PyObject *_wrap_new_NotebookSizer(PyObject *, PyObject *args, PyObject *kwargs) {
18467     PyObject *resultobj;
18468     wxNotebook *arg1 = (wxNotebook *) 0 ;
18469     wxNotebookSizer *result;
18470     PyObject * obj0 = 0 ;
18471     char *kwnames[] = {
18472         (char *) "nb", NULL
18473     };
18474
18475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NotebookSizer",kwnames,&obj0)) goto fail;
18476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebook, SWIG_POINTER_EXCEPTION | 0);
18477     if (SWIG_arg_fail(1)) SWIG_fail;
18478     {
18479         PyThreadState* __tstate = wxPyBeginAllowThreads();
18480         result = (wxNotebookSizer *)new wxNotebookSizer(arg1);
18481
18482         wxPyEndAllowThreads(__tstate);
18483         if (PyErr_Occurred()) SWIG_fail;
18484     }
18485     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotebookSizer, 1);
18486     return resultobj;
18487     fail:
18488     return NULL;
18489 }
18490
18491
18492 static PyObject *_wrap_NotebookSizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
18493     PyObject *resultobj;
18494     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18495     PyObject * obj0 = 0 ;
18496     char *kwnames[] = {
18497         (char *) "self", NULL
18498     };
18499
18500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_RecalcSizes",kwnames,&obj0)) goto fail;
18501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18502     if (SWIG_arg_fail(1)) SWIG_fail;
18503     {
18504         PyThreadState* __tstate = wxPyBeginAllowThreads();
18505         (arg1)->RecalcSizes();
18506
18507         wxPyEndAllowThreads(__tstate);
18508         if (PyErr_Occurred()) SWIG_fail;
18509     }
18510     Py_INCREF(Py_None); resultobj = Py_None;
18511     return resultobj;
18512     fail:
18513     return NULL;
18514 }
18515
18516
18517 static PyObject *_wrap_NotebookSizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
18518     PyObject *resultobj;
18519     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18520     wxSize result;
18521     PyObject * obj0 = 0 ;
18522     char *kwnames[] = {
18523         (char *) "self", NULL
18524     };
18525
18526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_CalcMin",kwnames,&obj0)) goto fail;
18527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18528     if (SWIG_arg_fail(1)) SWIG_fail;
18529     {
18530         PyThreadState* __tstate = wxPyBeginAllowThreads();
18531         result = (arg1)->CalcMin();
18532
18533         wxPyEndAllowThreads(__tstate);
18534         if (PyErr_Occurred()) SWIG_fail;
18535     }
18536     {
18537         wxSize * resultptr;
18538         resultptr = new wxSize((wxSize &)(result));
18539         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18540     }
18541     return resultobj;
18542     fail:
18543     return NULL;
18544 }
18545
18546
18547 static PyObject *_wrap_NotebookSizer_GetNotebook(PyObject *, PyObject *args, PyObject *kwargs) {
18548     PyObject *resultobj;
18549     wxNotebookSizer *arg1 = (wxNotebookSizer *) 0 ;
18550     wxNotebook *result;
18551     PyObject * obj0 = 0 ;
18552     char *kwnames[] = {
18553         (char *) "self", NULL
18554     };
18555
18556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotebookSizer_GetNotebook",kwnames,&obj0)) goto fail;
18557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotebookSizer, SWIG_POINTER_EXCEPTION | 0);
18558     if (SWIG_arg_fail(1)) SWIG_fail;
18559     {
18560         PyThreadState* __tstate = wxPyBeginAllowThreads();
18561         result = (wxNotebook *)(arg1)->GetNotebook();
18562
18563         wxPyEndAllowThreads(__tstate);
18564         if (PyErr_Occurred()) SWIG_fail;
18565     }
18566     {
18567         resultobj = wxPyMake_wxObject(result, 0);
18568     }
18569     return resultobj;
18570     fail:
18571     return NULL;
18572 }
18573
18574
18575 static PyObject * NotebookSizer_swigregister(PyObject *, PyObject *args) {
18576     PyObject *obj;
18577     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18578     SWIG_TypeClientData(SWIGTYPE_p_wxNotebookSizer, obj);
18579     Py_INCREF(obj);
18580     return Py_BuildValue((char *)"");
18581 }
18582 static PyObject *_wrap_ToolBarToolBase_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
18583     PyObject *resultobj;
18584     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18585     int result;
18586     PyObject * obj0 = 0 ;
18587     char *kwnames[] = {
18588         (char *) "self", NULL
18589     };
18590
18591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetId",kwnames,&obj0)) goto fail;
18592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18593     if (SWIG_arg_fail(1)) SWIG_fail;
18594     {
18595         PyThreadState* __tstate = wxPyBeginAllowThreads();
18596         result = (int)(arg1)->GetId();
18597
18598         wxPyEndAllowThreads(__tstate);
18599         if (PyErr_Occurred()) SWIG_fail;
18600     }
18601     {
18602         resultobj = SWIG_From_int((int)(result));
18603     }
18604     return resultobj;
18605     fail:
18606     return NULL;
18607 }
18608
18609
18610 static PyObject *_wrap_ToolBarToolBase_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18611     PyObject *resultobj;
18612     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18613     wxControl *result;
18614     PyObject * obj0 = 0 ;
18615     char *kwnames[] = {
18616         (char *) "self", NULL
18617     };
18618
18619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetControl",kwnames,&obj0)) goto fail;
18620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18621     if (SWIG_arg_fail(1)) SWIG_fail;
18622     {
18623         PyThreadState* __tstate = wxPyBeginAllowThreads();
18624         result = (wxControl *)(arg1)->GetControl();
18625
18626         wxPyEndAllowThreads(__tstate);
18627         if (PyErr_Occurred()) SWIG_fail;
18628     }
18629     {
18630         resultobj = wxPyMake_wxObject(result, 0);
18631     }
18632     return resultobj;
18633     fail:
18634     return NULL;
18635 }
18636
18637
18638 static PyObject *_wrap_ToolBarToolBase_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
18639     PyObject *resultobj;
18640     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18641     wxToolBarBase *result;
18642     PyObject * obj0 = 0 ;
18643     char *kwnames[] = {
18644         (char *) "self", NULL
18645     };
18646
18647     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetToolBar",kwnames,&obj0)) goto fail;
18648     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18649     if (SWIG_arg_fail(1)) SWIG_fail;
18650     {
18651         PyThreadState* __tstate = wxPyBeginAllowThreads();
18652         result = (wxToolBarBase *)(arg1)->GetToolBar();
18653
18654         wxPyEndAllowThreads(__tstate);
18655         if (PyErr_Occurred()) SWIG_fail;
18656     }
18657     {
18658         resultobj = wxPyMake_wxObject(result, 0);
18659     }
18660     return resultobj;
18661     fail:
18662     return NULL;
18663 }
18664
18665
18666 static PyObject *_wrap_ToolBarToolBase_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
18667     PyObject *resultobj;
18668     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18669     int result;
18670     PyObject * obj0 = 0 ;
18671     char *kwnames[] = {
18672         (char *) "self", NULL
18673     };
18674
18675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsButton",kwnames,&obj0)) goto fail;
18676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18677     if (SWIG_arg_fail(1)) SWIG_fail;
18678     {
18679         PyThreadState* __tstate = wxPyBeginAllowThreads();
18680         result = (int)(arg1)->IsButton();
18681
18682         wxPyEndAllowThreads(__tstate);
18683         if (PyErr_Occurred()) SWIG_fail;
18684     }
18685     {
18686         resultobj = SWIG_From_int((int)(result));
18687     }
18688     return resultobj;
18689     fail:
18690     return NULL;
18691 }
18692
18693
18694 static PyObject *_wrap_ToolBarToolBase_IsControl(PyObject *, PyObject *args, PyObject *kwargs) {
18695     PyObject *resultobj;
18696     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18697     int result;
18698     PyObject * obj0 = 0 ;
18699     char *kwnames[] = {
18700         (char *) "self", NULL
18701     };
18702
18703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsControl",kwnames,&obj0)) goto fail;
18704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18705     if (SWIG_arg_fail(1)) SWIG_fail;
18706     {
18707         PyThreadState* __tstate = wxPyBeginAllowThreads();
18708         result = (int)(arg1)->IsControl();
18709
18710         wxPyEndAllowThreads(__tstate);
18711         if (PyErr_Occurred()) SWIG_fail;
18712     }
18713     {
18714         resultobj = SWIG_From_int((int)(result));
18715     }
18716     return resultobj;
18717     fail:
18718     return NULL;
18719 }
18720
18721
18722 static PyObject *_wrap_ToolBarToolBase_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
18723     PyObject *resultobj;
18724     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18725     int result;
18726     PyObject * obj0 = 0 ;
18727     char *kwnames[] = {
18728         (char *) "self", NULL
18729     };
18730
18731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsSeparator",kwnames,&obj0)) goto fail;
18732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18733     if (SWIG_arg_fail(1)) SWIG_fail;
18734     {
18735         PyThreadState* __tstate = wxPyBeginAllowThreads();
18736         result = (int)(arg1)->IsSeparator();
18737
18738         wxPyEndAllowThreads(__tstate);
18739         if (PyErr_Occurred()) SWIG_fail;
18740     }
18741     {
18742         resultobj = SWIG_From_int((int)(result));
18743     }
18744     return resultobj;
18745     fail:
18746     return NULL;
18747 }
18748
18749
18750 static PyObject *_wrap_ToolBarToolBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18751     PyObject *resultobj;
18752     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18753     int result;
18754     PyObject * obj0 = 0 ;
18755     char *kwnames[] = {
18756         (char *) "self", NULL
18757     };
18758
18759     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetStyle",kwnames,&obj0)) goto fail;
18760     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18761     if (SWIG_arg_fail(1)) SWIG_fail;
18762     {
18763         PyThreadState* __tstate = wxPyBeginAllowThreads();
18764         result = (int)(arg1)->GetStyle();
18765
18766         wxPyEndAllowThreads(__tstate);
18767         if (PyErr_Occurred()) SWIG_fail;
18768     }
18769     {
18770         resultobj = SWIG_From_int((int)(result));
18771     }
18772     return resultobj;
18773     fail:
18774     return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_ToolBarToolBase_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
18779     PyObject *resultobj;
18780     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18781     wxItemKind result;
18782     PyObject * obj0 = 0 ;
18783     char *kwnames[] = {
18784         (char *) "self", NULL
18785     };
18786
18787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetKind",kwnames,&obj0)) goto fail;
18788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18789     if (SWIG_arg_fail(1)) SWIG_fail;
18790     {
18791         PyThreadState* __tstate = wxPyBeginAllowThreads();
18792         result = (wxItemKind)(arg1)->GetKind();
18793
18794         wxPyEndAllowThreads(__tstate);
18795         if (PyErr_Occurred()) SWIG_fail;
18796     }
18797     resultobj = SWIG_From_int((result));
18798     return resultobj;
18799     fail:
18800     return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_ToolBarToolBase_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
18805     PyObject *resultobj;
18806     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18807     bool result;
18808     PyObject * obj0 = 0 ;
18809     char *kwnames[] = {
18810         (char *) "self", NULL
18811     };
18812
18813     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsEnabled",kwnames,&obj0)) goto fail;
18814     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18815     if (SWIG_arg_fail(1)) SWIG_fail;
18816     {
18817         PyThreadState* __tstate = wxPyBeginAllowThreads();
18818         result = (bool)(arg1)->IsEnabled();
18819
18820         wxPyEndAllowThreads(__tstate);
18821         if (PyErr_Occurred()) SWIG_fail;
18822     }
18823     {
18824         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18825     }
18826     return resultobj;
18827     fail:
18828     return NULL;
18829 }
18830
18831
18832 static PyObject *_wrap_ToolBarToolBase_IsToggled(PyObject *, PyObject *args, PyObject *kwargs) {
18833     PyObject *resultobj;
18834     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18835     bool result;
18836     PyObject * obj0 = 0 ;
18837     char *kwnames[] = {
18838         (char *) "self", NULL
18839     };
18840
18841     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_IsToggled",kwnames,&obj0)) goto fail;
18842     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18843     if (SWIG_arg_fail(1)) SWIG_fail;
18844     {
18845         PyThreadState* __tstate = wxPyBeginAllowThreads();
18846         result = (bool)(arg1)->IsToggled();
18847
18848         wxPyEndAllowThreads(__tstate);
18849         if (PyErr_Occurred()) SWIG_fail;
18850     }
18851     {
18852         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18853     }
18854     return resultobj;
18855     fail:
18856     return NULL;
18857 }
18858
18859
18860 static PyObject *_wrap_ToolBarToolBase_CanBeToggled(PyObject *, PyObject *args, PyObject *kwargs) {
18861     PyObject *resultobj;
18862     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18863     bool result;
18864     PyObject * obj0 = 0 ;
18865     char *kwnames[] = {
18866         (char *) "self", NULL
18867     };
18868
18869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_CanBeToggled",kwnames,&obj0)) goto fail;
18870     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18871     if (SWIG_arg_fail(1)) SWIG_fail;
18872     {
18873         PyThreadState* __tstate = wxPyBeginAllowThreads();
18874         result = (bool)(arg1)->CanBeToggled();
18875
18876         wxPyEndAllowThreads(__tstate);
18877         if (PyErr_Occurred()) SWIG_fail;
18878     }
18879     {
18880         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18881     }
18882     return resultobj;
18883     fail:
18884     return NULL;
18885 }
18886
18887
18888 static PyObject *_wrap_ToolBarToolBase_GetNormalBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18889     PyObject *resultobj;
18890     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18891     wxBitmap *result;
18892     PyObject * obj0 = 0 ;
18893     char *kwnames[] = {
18894         (char *) "self", NULL
18895     };
18896
18897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetNormalBitmap",kwnames,&obj0)) goto fail;
18898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18899     if (SWIG_arg_fail(1)) SWIG_fail;
18900     {
18901         PyThreadState* __tstate = wxPyBeginAllowThreads();
18902         {
18903             wxBitmap const &_result_ref = (arg1)->GetNormalBitmap();
18904             result = (wxBitmap *) &_result_ref;
18905         }
18906
18907         wxPyEndAllowThreads(__tstate);
18908         if (PyErr_Occurred()) SWIG_fail;
18909     }
18910     {
18911         wxBitmap* resultptr = new wxBitmap(*result);
18912         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18913     }
18914     return resultobj;
18915     fail:
18916     return NULL;
18917 }
18918
18919
18920 static PyObject *_wrap_ToolBarToolBase_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18921     PyObject *resultobj;
18922     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18923     wxBitmap *result;
18924     PyObject * obj0 = 0 ;
18925     char *kwnames[] = {
18926         (char *) "self", NULL
18927     };
18928
18929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetDisabledBitmap",kwnames,&obj0)) goto fail;
18930     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18931     if (SWIG_arg_fail(1)) SWIG_fail;
18932     {
18933         PyThreadState* __tstate = wxPyBeginAllowThreads();
18934         {
18935             wxBitmap const &_result_ref = (arg1)->GetDisabledBitmap();
18936             result = (wxBitmap *) &_result_ref;
18937         }
18938
18939         wxPyEndAllowThreads(__tstate);
18940         if (PyErr_Occurred()) SWIG_fail;
18941     }
18942     {
18943         wxBitmap* resultptr = new wxBitmap(*result);
18944         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18945     }
18946     return resultobj;
18947     fail:
18948     return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_ToolBarToolBase_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18953     PyObject *resultobj;
18954     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18955     wxBitmap result;
18956     PyObject * obj0 = 0 ;
18957     char *kwnames[] = {
18958         (char *) "self", NULL
18959     };
18960
18961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetBitmap",kwnames,&obj0)) goto fail;
18962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18963     if (SWIG_arg_fail(1)) SWIG_fail;
18964     {
18965         PyThreadState* __tstate = wxPyBeginAllowThreads();
18966         result = (arg1)->GetBitmap();
18967
18968         wxPyEndAllowThreads(__tstate);
18969         if (PyErr_Occurred()) SWIG_fail;
18970     }
18971     {
18972         wxBitmap * resultptr;
18973         resultptr = new wxBitmap((wxBitmap &)(result));
18974         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18975     }
18976     return resultobj;
18977     fail:
18978     return NULL;
18979 }
18980
18981
18982 static PyObject *_wrap_ToolBarToolBase_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
18983     PyObject *resultobj;
18984     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
18985     wxString result;
18986     PyObject * obj0 = 0 ;
18987     char *kwnames[] = {
18988         (char *) "self", NULL
18989     };
18990
18991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetLabel",kwnames,&obj0)) goto fail;
18992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
18993     if (SWIG_arg_fail(1)) SWIG_fail;
18994     {
18995         PyThreadState* __tstate = wxPyBeginAllowThreads();
18996         result = (arg1)->GetLabel();
18997
18998         wxPyEndAllowThreads(__tstate);
18999         if (PyErr_Occurred()) SWIG_fail;
19000     }
19001     {
19002 #if wxUSE_UNICODE
19003         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19004 #else
19005         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19006 #endif
19007     }
19008     return resultobj;
19009     fail:
19010     return NULL;
19011 }
19012
19013
19014 static PyObject *_wrap_ToolBarToolBase_GetShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19015     PyObject *resultobj;
19016     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19017     wxString result;
19018     PyObject * obj0 = 0 ;
19019     char *kwnames[] = {
19020         (char *) "self", NULL
19021     };
19022
19023     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetShortHelp",kwnames,&obj0)) goto fail;
19024     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19025     if (SWIG_arg_fail(1)) SWIG_fail;
19026     {
19027         PyThreadState* __tstate = wxPyBeginAllowThreads();
19028         result = (arg1)->GetShortHelp();
19029
19030         wxPyEndAllowThreads(__tstate);
19031         if (PyErr_Occurred()) SWIG_fail;
19032     }
19033     {
19034 #if wxUSE_UNICODE
19035         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19036 #else
19037         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19038 #endif
19039     }
19040     return resultobj;
19041     fail:
19042     return NULL;
19043 }
19044
19045
19046 static PyObject *_wrap_ToolBarToolBase_GetLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19047     PyObject *resultobj;
19048     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19049     wxString result;
19050     PyObject * obj0 = 0 ;
19051     char *kwnames[] = {
19052         (char *) "self", NULL
19053     };
19054
19055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetLongHelp",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
19060         result = (arg1)->GetLongHelp();
19061
19062         wxPyEndAllowThreads(__tstate);
19063         if (PyErr_Occurred()) SWIG_fail;
19064     }
19065     {
19066 #if wxUSE_UNICODE
19067         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19068 #else
19069         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19070 #endif
19071     }
19072     return resultobj;
19073     fail:
19074     return NULL;
19075 }
19076
19077
19078 static PyObject *_wrap_ToolBarToolBase_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
19079     PyObject *resultobj;
19080     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19081     bool arg2 ;
19082     bool result;
19083     PyObject * obj0 = 0 ;
19084     PyObject * obj1 = 0 ;
19085     char *kwnames[] = {
19086         (char *) "self",(char *) "enable", NULL
19087     };
19088
19089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Enable",kwnames,&obj0,&obj1)) goto fail;
19090     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19091     if (SWIG_arg_fail(1)) SWIG_fail;
19092     {
19093         arg2 = (bool)(SWIG_As_bool(obj1));
19094         if (SWIG_arg_fail(2)) SWIG_fail;
19095     }
19096     {
19097         PyThreadState* __tstate = wxPyBeginAllowThreads();
19098         result = (bool)(arg1)->Enable(arg2);
19099
19100         wxPyEndAllowThreads(__tstate);
19101         if (PyErr_Occurred()) SWIG_fail;
19102     }
19103     {
19104         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19105     }
19106     return resultobj;
19107     fail:
19108     return NULL;
19109 }
19110
19111
19112 static PyObject *_wrap_ToolBarToolBase_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
19113     PyObject *resultobj;
19114     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19115     PyObject * obj0 = 0 ;
19116     char *kwnames[] = {
19117         (char *) "self", NULL
19118     };
19119
19120     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_Toggle",kwnames,&obj0)) goto fail;
19121     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19122     if (SWIG_arg_fail(1)) SWIG_fail;
19123     {
19124         PyThreadState* __tstate = wxPyBeginAllowThreads();
19125         (arg1)->Toggle();
19126
19127         wxPyEndAllowThreads(__tstate);
19128         if (PyErr_Occurred()) SWIG_fail;
19129     }
19130     Py_INCREF(Py_None); resultobj = Py_None;
19131     return resultobj;
19132     fail:
19133     return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_ToolBarToolBase_SetToggle(PyObject *, PyObject *args, PyObject *kwargs) {
19138     PyObject *resultobj;
19139     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19140     bool arg2 ;
19141     bool result;
19142     PyObject * obj0 = 0 ;
19143     PyObject * obj1 = 0 ;
19144     char *kwnames[] = {
19145         (char *) "self",(char *) "toggle", NULL
19146     };
19147
19148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetToggle",kwnames,&obj0,&obj1)) goto fail;
19149     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19150     if (SWIG_arg_fail(1)) SWIG_fail;
19151     {
19152         arg2 = (bool)(SWIG_As_bool(obj1));
19153         if (SWIG_arg_fail(2)) SWIG_fail;
19154     }
19155     {
19156         PyThreadState* __tstate = wxPyBeginAllowThreads();
19157         result = (bool)(arg1)->SetToggle(arg2);
19158
19159         wxPyEndAllowThreads(__tstate);
19160         if (PyErr_Occurred()) SWIG_fail;
19161     }
19162     {
19163         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19164     }
19165     return resultobj;
19166     fail:
19167     return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_ToolBarToolBase_SetShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19172     PyObject *resultobj;
19173     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19174     wxString *arg2 = 0 ;
19175     bool result;
19176     bool temp2 = false ;
19177     PyObject * obj0 = 0 ;
19178     PyObject * obj1 = 0 ;
19179     char *kwnames[] = {
19180         (char *) "self",(char *) "help", NULL
19181     };
19182
19183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetShortHelp",kwnames,&obj0,&obj1)) goto fail;
19184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19185     if (SWIG_arg_fail(1)) SWIG_fail;
19186     {
19187         arg2 = wxString_in_helper(obj1);
19188         if (arg2 == NULL) SWIG_fail;
19189         temp2 = true;
19190     }
19191     {
19192         PyThreadState* __tstate = wxPyBeginAllowThreads();
19193         result = (bool)(arg1)->SetShortHelp((wxString const &)*arg2);
19194
19195         wxPyEndAllowThreads(__tstate);
19196         if (PyErr_Occurred()) SWIG_fail;
19197     }
19198     {
19199         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19200     }
19201     {
19202         if (temp2)
19203         delete arg2;
19204     }
19205     return resultobj;
19206     fail:
19207     {
19208         if (temp2)
19209         delete arg2;
19210     }
19211     return NULL;
19212 }
19213
19214
19215 static PyObject *_wrap_ToolBarToolBase_SetLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
19216     PyObject *resultobj;
19217     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19218     wxString *arg2 = 0 ;
19219     bool result;
19220     bool temp2 = false ;
19221     PyObject * obj0 = 0 ;
19222     PyObject * obj1 = 0 ;
19223     char *kwnames[] = {
19224         (char *) "self",(char *) "help", NULL
19225     };
19226
19227     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLongHelp",kwnames,&obj0,&obj1)) goto fail;
19228     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19229     if (SWIG_arg_fail(1)) SWIG_fail;
19230     {
19231         arg2 = wxString_in_helper(obj1);
19232         if (arg2 == NULL) SWIG_fail;
19233         temp2 = true;
19234     }
19235     {
19236         PyThreadState* __tstate = wxPyBeginAllowThreads();
19237         result = (bool)(arg1)->SetLongHelp((wxString const &)*arg2);
19238
19239         wxPyEndAllowThreads(__tstate);
19240         if (PyErr_Occurred()) SWIG_fail;
19241     }
19242     {
19243         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19244     }
19245     {
19246         if (temp2)
19247         delete arg2;
19248     }
19249     return resultobj;
19250     fail:
19251     {
19252         if (temp2)
19253         delete arg2;
19254     }
19255     return NULL;
19256 }
19257
19258
19259 static PyObject *_wrap_ToolBarToolBase_SetNormalBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19260     PyObject *resultobj;
19261     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19262     wxBitmap *arg2 = 0 ;
19263     PyObject * obj0 = 0 ;
19264     PyObject * obj1 = 0 ;
19265     char *kwnames[] = {
19266         (char *) "self",(char *) "bmp", NULL
19267     };
19268
19269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetNormalBitmap",kwnames,&obj0,&obj1)) goto fail;
19270     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19271     if (SWIG_arg_fail(1)) SWIG_fail;
19272     {
19273         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19274         if (SWIG_arg_fail(2)) SWIG_fail;
19275         if (arg2 == NULL) {
19276             SWIG_null_ref("wxBitmap");
19277         }
19278         if (SWIG_arg_fail(2)) SWIG_fail;
19279     }
19280     {
19281         PyThreadState* __tstate = wxPyBeginAllowThreads();
19282         (arg1)->SetNormalBitmap((wxBitmap const &)*arg2);
19283
19284         wxPyEndAllowThreads(__tstate);
19285         if (PyErr_Occurred()) SWIG_fail;
19286     }
19287     Py_INCREF(Py_None); resultobj = Py_None;
19288     return resultobj;
19289     fail:
19290     return NULL;
19291 }
19292
19293
19294 static PyObject *_wrap_ToolBarToolBase_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19295     PyObject *resultobj;
19296     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19297     wxBitmap *arg2 = 0 ;
19298     PyObject * obj0 = 0 ;
19299     PyObject * obj1 = 0 ;
19300     char *kwnames[] = {
19301         (char *) "self",(char *) "bmp", NULL
19302     };
19303
19304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
19305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19306     if (SWIG_arg_fail(1)) SWIG_fail;
19307     {
19308         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19309         if (SWIG_arg_fail(2)) SWIG_fail;
19310         if (arg2 == NULL) {
19311             SWIG_null_ref("wxBitmap");
19312         }
19313         if (SWIG_arg_fail(2)) SWIG_fail;
19314     }
19315     {
19316         PyThreadState* __tstate = wxPyBeginAllowThreads();
19317         (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
19318
19319         wxPyEndAllowThreads(__tstate);
19320         if (PyErr_Occurred()) SWIG_fail;
19321     }
19322     Py_INCREF(Py_None); resultobj = Py_None;
19323     return resultobj;
19324     fail:
19325     return NULL;
19326 }
19327
19328
19329 static PyObject *_wrap_ToolBarToolBase_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
19330     PyObject *resultobj;
19331     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19332     wxString *arg2 = 0 ;
19333     bool temp2 = false ;
19334     PyObject * obj0 = 0 ;
19335     PyObject * obj1 = 0 ;
19336     char *kwnames[] = {
19337         (char *) "self",(char *) "label", NULL
19338     };
19339
19340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLabel",kwnames,&obj0,&obj1)) goto fail;
19341     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19342     if (SWIG_arg_fail(1)) SWIG_fail;
19343     {
19344         arg2 = wxString_in_helper(obj1);
19345         if (arg2 == NULL) SWIG_fail;
19346         temp2 = true;
19347     }
19348     {
19349         PyThreadState* __tstate = wxPyBeginAllowThreads();
19350         (arg1)->SetLabel((wxString const &)*arg2);
19351
19352         wxPyEndAllowThreads(__tstate);
19353         if (PyErr_Occurred()) SWIG_fail;
19354     }
19355     Py_INCREF(Py_None); resultobj = Py_None;
19356     {
19357         if (temp2)
19358         delete arg2;
19359     }
19360     return resultobj;
19361     fail:
19362     {
19363         if (temp2)
19364         delete arg2;
19365     }
19366     return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_ToolBarToolBase_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
19371     PyObject *resultobj;
19372     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19373     PyObject * obj0 = 0 ;
19374     char *kwnames[] = {
19375         (char *) "self", NULL
19376     };
19377
19378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_Detach",kwnames,&obj0)) goto fail;
19379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19380     if (SWIG_arg_fail(1)) SWIG_fail;
19381     {
19382         PyThreadState* __tstate = wxPyBeginAllowThreads();
19383         (arg1)->Detach();
19384
19385         wxPyEndAllowThreads(__tstate);
19386         if (PyErr_Occurred()) SWIG_fail;
19387     }
19388     Py_INCREF(Py_None); resultobj = Py_None;
19389     return resultobj;
19390     fail:
19391     return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_ToolBarToolBase_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
19396     PyObject *resultobj;
19397     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19398     wxToolBarBase *arg2 = (wxToolBarBase *) 0 ;
19399     PyObject * obj0 = 0 ;
19400     PyObject * obj1 = 0 ;
19401     char *kwnames[] = {
19402         (char *) "self",(char *) "tbar", NULL
19403     };
19404
19405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Attach",kwnames,&obj0,&obj1)) goto fail;
19406     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19407     if (SWIG_arg_fail(1)) SWIG_fail;
19408     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19409     if (SWIG_arg_fail(2)) SWIG_fail;
19410     {
19411         PyThreadState* __tstate = wxPyBeginAllowThreads();
19412         (arg1)->Attach(arg2);
19413
19414         wxPyEndAllowThreads(__tstate);
19415         if (PyErr_Occurred()) SWIG_fail;
19416     }
19417     Py_INCREF(Py_None); resultobj = Py_None;
19418     return resultobj;
19419     fail:
19420     return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_ToolBarToolBase_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
19425     PyObject *resultobj;
19426     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19427     PyObject *result;
19428     PyObject * obj0 = 0 ;
19429     char *kwnames[] = {
19430         (char *) "self", NULL
19431     };
19432
19433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarToolBase_GetClientData",kwnames,&obj0)) goto fail;
19434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19435     if (SWIG_arg_fail(1)) SWIG_fail;
19436     {
19437         PyThreadState* __tstate = wxPyBeginAllowThreads();
19438         result = (PyObject *)wxToolBarToolBase_GetClientData(arg1);
19439
19440         wxPyEndAllowThreads(__tstate);
19441         if (PyErr_Occurred()) SWIG_fail;
19442     }
19443     resultobj = result;
19444     return resultobj;
19445     fail:
19446     return NULL;
19447 }
19448
19449
19450 static PyObject *_wrap_ToolBarToolBase_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
19451     PyObject *resultobj;
19452     wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
19453     PyObject *arg2 = (PyObject *) 0 ;
19454     PyObject * obj0 = 0 ;
19455     PyObject * obj1 = 0 ;
19456     char *kwnames[] = {
19457         (char *) "self",(char *) "clientData", NULL
19458     };
19459
19460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetClientData",kwnames,&obj0,&obj1)) goto fail;
19461     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19462     if (SWIG_arg_fail(1)) SWIG_fail;
19463     arg2 = obj1;
19464     {
19465         PyThreadState* __tstate = wxPyBeginAllowThreads();
19466         wxToolBarToolBase_SetClientData(arg1,arg2);
19467
19468         wxPyEndAllowThreads(__tstate);
19469         if (PyErr_Occurred()) SWIG_fail;
19470     }
19471     Py_INCREF(Py_None); resultobj = Py_None;
19472     return resultobj;
19473     fail:
19474     return NULL;
19475 }
19476
19477
19478 static PyObject * ToolBarToolBase_swigregister(PyObject *, PyObject *args) {
19479     PyObject *obj;
19480     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19481     SWIG_TypeClientData(SWIGTYPE_p_wxToolBarToolBase, obj);
19482     Py_INCREF(obj);
19483     return Py_BuildValue((char *)"");
19484 }
19485 static PyObject *_wrap_ToolBarBase_DoAddTool(PyObject *, PyObject *args, PyObject *kwargs) {
19486     PyObject *resultobj;
19487     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19488     int arg2 ;
19489     wxString *arg3 = 0 ;
19490     wxBitmap *arg4 = 0 ;
19491     wxBitmap const &arg5_defvalue = wxNullBitmap ;
19492     wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
19493     wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
19494     wxString const &arg7_defvalue = wxPyEmptyString ;
19495     wxString *arg7 = (wxString *) &arg7_defvalue ;
19496     wxString const &arg8_defvalue = wxPyEmptyString ;
19497     wxString *arg8 = (wxString *) &arg8_defvalue ;
19498     PyObject *arg9 = (PyObject *) NULL ;
19499     wxToolBarToolBase *result;
19500     bool temp3 = false ;
19501     bool temp7 = false ;
19502     bool temp8 = false ;
19503     PyObject * obj0 = 0 ;
19504     PyObject * obj1 = 0 ;
19505     PyObject * obj2 = 0 ;
19506     PyObject * obj3 = 0 ;
19507     PyObject * obj4 = 0 ;
19508     PyObject * obj5 = 0 ;
19509     PyObject * obj6 = 0 ;
19510     PyObject * obj7 = 0 ;
19511     PyObject * obj8 = 0 ;
19512     char *kwnames[] = {
19513         (char *) "self",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL
19514     };
19515
19516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOOO:ToolBarBase_DoAddTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
19517     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19518     if (SWIG_arg_fail(1)) SWIG_fail;
19519     {
19520         arg2 = (int)(SWIG_As_int(obj1));
19521         if (SWIG_arg_fail(2)) SWIG_fail;
19522     }
19523     {
19524         arg3 = wxString_in_helper(obj2);
19525         if (arg3 == NULL) SWIG_fail;
19526         temp3 = true;
19527     }
19528     {
19529         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19530         if (SWIG_arg_fail(4)) SWIG_fail;
19531         if (arg4 == NULL) {
19532             SWIG_null_ref("wxBitmap");
19533         }
19534         if (SWIG_arg_fail(4)) SWIG_fail;
19535     }
19536     if (obj4) {
19537         {
19538             SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19539             if (SWIG_arg_fail(5)) SWIG_fail;
19540             if (arg5 == NULL) {
19541                 SWIG_null_ref("wxBitmap");
19542             }
19543             if (SWIG_arg_fail(5)) SWIG_fail;
19544         }
19545     }
19546     if (obj5) {
19547         {
19548             arg6 = (wxItemKind)(SWIG_As_int(obj5));
19549             if (SWIG_arg_fail(6)) SWIG_fail;
19550         }
19551     }
19552     if (obj6) {
19553         {
19554             arg7 = wxString_in_helper(obj6);
19555             if (arg7 == NULL) SWIG_fail;
19556             temp7 = true;
19557         }
19558     }
19559     if (obj7) {
19560         {
19561             arg8 = wxString_in_helper(obj7);
19562             if (arg8 == NULL) SWIG_fail;
19563             temp8 = true;
19564         }
19565     }
19566     if (obj8) {
19567         arg9 = obj8;
19568     }
19569     {
19570         PyThreadState* __tstate = wxPyBeginAllowThreads();
19571         result = (wxToolBarToolBase *)wxToolBarBase_DoAddTool(arg1,arg2,(wxString const &)*arg3,(wxBitmap const &)*arg4,(wxBitmap const &)*arg5,(wxItemKind )arg6,(wxString const &)*arg7,(wxString const &)*arg8,arg9);
19572
19573         wxPyEndAllowThreads(__tstate);
19574         if (PyErr_Occurred()) SWIG_fail;
19575     }
19576     {
19577         resultobj = wxPyMake_wxObject(result, 0);
19578     }
19579     {
19580         if (temp3)
19581         delete arg3;
19582     }
19583     {
19584         if (temp7)
19585         delete arg7;
19586     }
19587     {
19588         if (temp8)
19589         delete arg8;
19590     }
19591     return resultobj;
19592     fail:
19593     {
19594         if (temp3)
19595         delete arg3;
19596     }
19597     {
19598         if (temp7)
19599         delete arg7;
19600     }
19601     {
19602         if (temp8)
19603         delete arg8;
19604     }
19605     return NULL;
19606 }
19607
19608
19609 static PyObject *_wrap_ToolBarBase_DoInsertTool(PyObject *, PyObject *args, PyObject *kwargs) {
19610     PyObject *resultobj;
19611     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19612     size_t arg2 ;
19613     int arg3 ;
19614     wxString *arg4 = 0 ;
19615     wxBitmap *arg5 = 0 ;
19616     wxBitmap const &arg6_defvalue = wxNullBitmap ;
19617     wxBitmap *arg6 = (wxBitmap *) &arg6_defvalue ;
19618     wxItemKind arg7 = (wxItemKind) wxITEM_NORMAL ;
19619     wxString const &arg8_defvalue = wxPyEmptyString ;
19620     wxString *arg8 = (wxString *) &arg8_defvalue ;
19621     wxString const &arg9_defvalue = wxPyEmptyString ;
19622     wxString *arg9 = (wxString *) &arg9_defvalue ;
19623     PyObject *arg10 = (PyObject *) NULL ;
19624     wxToolBarToolBase *result;
19625     bool temp4 = false ;
19626     bool temp8 = false ;
19627     bool temp9 = false ;
19628     PyObject * obj0 = 0 ;
19629     PyObject * obj1 = 0 ;
19630     PyObject * obj2 = 0 ;
19631     PyObject * obj3 = 0 ;
19632     PyObject * obj4 = 0 ;
19633     PyObject * obj5 = 0 ;
19634     PyObject * obj6 = 0 ;
19635     PyObject * obj7 = 0 ;
19636     PyObject * obj8 = 0 ;
19637     PyObject * obj9 = 0 ;
19638     char *kwnames[] = {
19639         (char *) "self",(char *) "pos",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL
19640     };
19641
19642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:ToolBarBase_DoInsertTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
19643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19644     if (SWIG_arg_fail(1)) SWIG_fail;
19645     {
19646         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19647         if (SWIG_arg_fail(2)) SWIG_fail;
19648     }
19649     {
19650         arg3 = (int)(SWIG_As_int(obj2));
19651         if (SWIG_arg_fail(3)) SWIG_fail;
19652     }
19653     {
19654         arg4 = wxString_in_helper(obj3);
19655         if (arg4 == NULL) SWIG_fail;
19656         temp4 = true;
19657     }
19658     {
19659         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19660         if (SWIG_arg_fail(5)) SWIG_fail;
19661         if (arg5 == NULL) {
19662             SWIG_null_ref("wxBitmap");
19663         }
19664         if (SWIG_arg_fail(5)) SWIG_fail;
19665     }
19666     if (obj5) {
19667         {
19668             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19669             if (SWIG_arg_fail(6)) SWIG_fail;
19670             if (arg6 == NULL) {
19671                 SWIG_null_ref("wxBitmap");
19672             }
19673             if (SWIG_arg_fail(6)) SWIG_fail;
19674         }
19675     }
19676     if (obj6) {
19677         {
19678             arg7 = (wxItemKind)(SWIG_As_int(obj6));
19679             if (SWIG_arg_fail(7)) SWIG_fail;
19680         }
19681     }
19682     if (obj7) {
19683         {
19684             arg8 = wxString_in_helper(obj7);
19685             if (arg8 == NULL) SWIG_fail;
19686             temp8 = true;
19687         }
19688     }
19689     if (obj8) {
19690         {
19691             arg9 = wxString_in_helper(obj8);
19692             if (arg9 == NULL) SWIG_fail;
19693             temp9 = true;
19694         }
19695     }
19696     if (obj9) {
19697         arg10 = obj9;
19698     }
19699     {
19700         PyThreadState* __tstate = wxPyBeginAllowThreads();
19701         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);
19702
19703         wxPyEndAllowThreads(__tstate);
19704         if (PyErr_Occurred()) SWIG_fail;
19705     }
19706     {
19707         resultobj = wxPyMake_wxObject(result, 0);
19708     }
19709     {
19710         if (temp4)
19711         delete arg4;
19712     }
19713     {
19714         if (temp8)
19715         delete arg8;
19716     }
19717     {
19718         if (temp9)
19719         delete arg9;
19720     }
19721     return resultobj;
19722     fail:
19723     {
19724         if (temp4)
19725         delete arg4;
19726     }
19727     {
19728         if (temp8)
19729         delete arg8;
19730     }
19731     {
19732         if (temp9)
19733         delete arg9;
19734     }
19735     return NULL;
19736 }
19737
19738
19739 static PyObject *_wrap_ToolBarBase_AddToolItem(PyObject *, PyObject *args, PyObject *kwargs) {
19740     PyObject *resultobj;
19741     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19742     wxToolBarToolBase *arg2 = (wxToolBarToolBase *) 0 ;
19743     wxToolBarToolBase *result;
19744     PyObject * obj0 = 0 ;
19745     PyObject * obj1 = 0 ;
19746     char *kwnames[] = {
19747         (char *) "self",(char *) "tool", NULL
19748     };
19749
19750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddToolItem",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19754     if (SWIG_arg_fail(2)) SWIG_fail;
19755     {
19756         PyThreadState* __tstate = wxPyBeginAllowThreads();
19757         result = (wxToolBarToolBase *)(arg1)->AddTool(arg2);
19758
19759         wxPyEndAllowThreads(__tstate);
19760         if (PyErr_Occurred()) SWIG_fail;
19761     }
19762     {
19763         resultobj = wxPyMake_wxObject(result, 0);
19764     }
19765     return resultobj;
19766     fail:
19767     return NULL;
19768 }
19769
19770
19771 static PyObject *_wrap_ToolBarBase_InsertToolItem(PyObject *, PyObject *args, PyObject *kwargs) {
19772     PyObject *resultobj;
19773     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19774     size_t arg2 ;
19775     wxToolBarToolBase *arg3 = (wxToolBarToolBase *) 0 ;
19776     wxToolBarToolBase *result;
19777     PyObject * obj0 = 0 ;
19778     PyObject * obj1 = 0 ;
19779     PyObject * obj2 = 0 ;
19780     char *kwnames[] = {
19781         (char *) "self",(char *) "pos",(char *) "tool", NULL
19782     };
19783
19784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertToolItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
19785     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19786     if (SWIG_arg_fail(1)) SWIG_fail;
19787     {
19788         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19789         if (SWIG_arg_fail(2)) SWIG_fail;
19790     }
19791     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxToolBarToolBase, SWIG_POINTER_EXCEPTION | 0);
19792     if (SWIG_arg_fail(3)) SWIG_fail;
19793     {
19794         PyThreadState* __tstate = wxPyBeginAllowThreads();
19795         result = (wxToolBarToolBase *)(arg1)->InsertTool(arg2,arg3);
19796
19797         wxPyEndAllowThreads(__tstate);
19798         if (PyErr_Occurred()) SWIG_fail;
19799     }
19800     {
19801         resultobj = wxPyMake_wxObject(result, 0);
19802     }
19803     return resultobj;
19804     fail:
19805     return NULL;
19806 }
19807
19808
19809 static PyObject *_wrap_ToolBarBase_AddControl(PyObject *, PyObject *args, PyObject *kwargs) {
19810     PyObject *resultobj;
19811     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19812     wxControl *arg2 = (wxControl *) 0 ;
19813     wxToolBarToolBase *result;
19814     PyObject * obj0 = 0 ;
19815     PyObject * obj1 = 0 ;
19816     char *kwnames[] = {
19817         (char *) "self",(char *) "control", NULL
19818     };
19819
19820     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddControl",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
19824     if (SWIG_arg_fail(2)) SWIG_fail;
19825     {
19826         PyThreadState* __tstate = wxPyBeginAllowThreads();
19827         result = (wxToolBarToolBase *)(arg1)->AddControl(arg2);
19828
19829         wxPyEndAllowThreads(__tstate);
19830         if (PyErr_Occurred()) SWIG_fail;
19831     }
19832     {
19833         resultobj = wxPyMake_wxObject(result, 0);
19834     }
19835     return resultobj;
19836     fail:
19837     return NULL;
19838 }
19839
19840
19841 static PyObject *_wrap_ToolBarBase_InsertControl(PyObject *, PyObject *args, PyObject *kwargs) {
19842     PyObject *resultobj;
19843     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19844     size_t arg2 ;
19845     wxControl *arg3 = (wxControl *) 0 ;
19846     wxToolBarToolBase *result;
19847     PyObject * obj0 = 0 ;
19848     PyObject * obj1 = 0 ;
19849     PyObject * obj2 = 0 ;
19850     char *kwnames[] = {
19851         (char *) "self",(char *) "pos",(char *) "control", NULL
19852     };
19853
19854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertControl",kwnames,&obj0,&obj1,&obj2)) goto fail;
19855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19856     if (SWIG_arg_fail(1)) SWIG_fail;
19857     {
19858         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19859         if (SWIG_arg_fail(2)) SWIG_fail;
19860     }
19861     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
19862     if (SWIG_arg_fail(3)) SWIG_fail;
19863     {
19864         PyThreadState* __tstate = wxPyBeginAllowThreads();
19865         result = (wxToolBarToolBase *)(arg1)->InsertControl(arg2,arg3);
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_FindControl(PyObject *, PyObject *args, PyObject *kwargs) {
19880     PyObject *resultobj;
19881     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19882     int arg2 ;
19883     wxControl *result;
19884     PyObject * obj0 = 0 ;
19885     PyObject * obj1 = 0 ;
19886     char *kwnames[] = {
19887         (char *) "self",(char *) "id", NULL
19888     };
19889
19890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindControl",kwnames,&obj0,&obj1)) goto fail;
19891     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19892     if (SWIG_arg_fail(1)) SWIG_fail;
19893     {
19894         arg2 = (int)(SWIG_As_int(obj1));
19895         if (SWIG_arg_fail(2)) SWIG_fail;
19896     }
19897     {
19898         PyThreadState* __tstate = wxPyBeginAllowThreads();
19899         result = (wxControl *)(arg1)->FindControl(arg2);
19900
19901         wxPyEndAllowThreads(__tstate);
19902         if (PyErr_Occurred()) SWIG_fail;
19903     }
19904     {
19905         resultobj = wxPyMake_wxObject(result, 0);
19906     }
19907     return resultobj;
19908     fail:
19909     return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_ToolBarBase_AddSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
19914     PyObject *resultobj;
19915     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19916     wxToolBarToolBase *result;
19917     PyObject * obj0 = 0 ;
19918     char *kwnames[] = {
19919         (char *) "self", NULL
19920     };
19921
19922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_AddSeparator",kwnames,&obj0)) goto fail;
19923     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
19924     if (SWIG_arg_fail(1)) SWIG_fail;
19925     {
19926         PyThreadState* __tstate = wxPyBeginAllowThreads();
19927         result = (wxToolBarToolBase *)(arg1)->AddSeparator();
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_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
19942     PyObject *resultobj;
19943     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19944     size_t arg2 ;
19945     wxToolBarToolBase *result;
19946     PyObject * obj0 = 0 ;
19947     PyObject * obj1 = 0 ;
19948     char *kwnames[] = {
19949         (char *) "self",(char *) "pos", NULL
19950     };
19951
19952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_InsertSeparator",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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
19957         if (SWIG_arg_fail(2)) SWIG_fail;
19958     }
19959     {
19960         PyThreadState* __tstate = wxPyBeginAllowThreads();
19961         result = (wxToolBarToolBase *)(arg1)->InsertSeparator(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_RemoveTool(PyObject *, PyObject *args, PyObject *kwargs) {
19976     PyObject *resultobj;
19977     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
19978     int arg2 ;
19979     wxToolBarToolBase *result;
19980     PyObject * obj0 = 0 ;
19981     PyObject * obj1 = 0 ;
19982     char *kwnames[] = {
19983         (char *) "self",(char *) "id", NULL
19984     };
19985
19986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_RemoveTool",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 = (int)(SWIG_As_int(obj1));
19991         if (SWIG_arg_fail(2)) SWIG_fail;
19992     }
19993     {
19994         PyThreadState* __tstate = wxPyBeginAllowThreads();
19995         result = (wxToolBarToolBase *)(arg1)->RemoveTool(arg2);
19996
19997         wxPyEndAllowThreads(__tstate);
19998         if (PyErr_Occurred()) SWIG_fail;
19999     }
20000     {
20001         resultobj = wxPyMake_wxObject(result, 0);
20002     }
20003     return resultobj;
20004     fail:
20005     return NULL;
20006 }
20007
20008
20009 static PyObject *_wrap_ToolBarBase_DeleteToolByPos(PyObject *, PyObject *args, PyObject *kwargs) {
20010     PyObject *resultobj;
20011     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20012     size_t arg2 ;
20013     bool result;
20014     PyObject * obj0 = 0 ;
20015     PyObject * obj1 = 0 ;
20016     char *kwnames[] = {
20017         (char *) "self",(char *) "pos", NULL
20018     };
20019
20020     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteToolByPos",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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
20025         if (SWIG_arg_fail(2)) SWIG_fail;
20026     }
20027     {
20028         PyThreadState* __tstate = wxPyBeginAllowThreads();
20029         result = (bool)(arg1)->DeleteToolByPos(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_DeleteTool(PyObject *, PyObject *args, PyObject *kwargs) {
20044     PyObject *resultobj;
20045     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20046     int arg2 ;
20047     bool result;
20048     PyObject * obj0 = 0 ;
20049     PyObject * obj1 = 0 ;
20050     char *kwnames[] = {
20051         (char *) "self",(char *) "id", NULL
20052     };
20053
20054     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteTool",kwnames,&obj0,&obj1)) goto fail;
20055     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20056     if (SWIG_arg_fail(1)) SWIG_fail;
20057     {
20058         arg2 = (int)(SWIG_As_int(obj1));
20059         if (SWIG_arg_fail(2)) SWIG_fail;
20060     }
20061     {
20062         PyThreadState* __tstate = wxPyBeginAllowThreads();
20063         result = (bool)(arg1)->DeleteTool(arg2);
20064
20065         wxPyEndAllowThreads(__tstate);
20066         if (PyErr_Occurred()) SWIG_fail;
20067     }
20068     {
20069         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20070     }
20071     return resultobj;
20072     fail:
20073     return NULL;
20074 }
20075
20076
20077 static PyObject *_wrap_ToolBarBase_ClearTools(PyObject *, PyObject *args, PyObject *kwargs) {
20078     PyObject *resultobj;
20079     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20080     PyObject * obj0 = 0 ;
20081     char *kwnames[] = {
20082         (char *) "self", NULL
20083     };
20084
20085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_ClearTools",kwnames,&obj0)) goto fail;
20086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20087     if (SWIG_arg_fail(1)) SWIG_fail;
20088     {
20089         PyThreadState* __tstate = wxPyBeginAllowThreads();
20090         (arg1)->ClearTools();
20091
20092         wxPyEndAllowThreads(__tstate);
20093         if (PyErr_Occurred()) SWIG_fail;
20094     }
20095     Py_INCREF(Py_None); resultobj = Py_None;
20096     return resultobj;
20097     fail:
20098     return NULL;
20099 }
20100
20101
20102 static PyObject *_wrap_ToolBarBase_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
20103     PyObject *resultobj;
20104     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20105     bool result;
20106     PyObject * obj0 = 0 ;
20107     char *kwnames[] = {
20108         (char *) "self", NULL
20109     };
20110
20111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_Realize",kwnames,&obj0)) goto fail;
20112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20113     if (SWIG_arg_fail(1)) SWIG_fail;
20114     {
20115         PyThreadState* __tstate = wxPyBeginAllowThreads();
20116         result = (bool)(arg1)->Realize();
20117
20118         wxPyEndAllowThreads(__tstate);
20119         if (PyErr_Occurred()) SWIG_fail;
20120     }
20121     {
20122         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20123     }
20124     return resultobj;
20125     fail:
20126     return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_ToolBarBase_EnableTool(PyObject *, PyObject *args, PyObject *kwargs) {
20131     PyObject *resultobj;
20132     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20133     int arg2 ;
20134     bool arg3 ;
20135     PyObject * obj0 = 0 ;
20136     PyObject * obj1 = 0 ;
20137     PyObject * obj2 = 0 ;
20138     char *kwnames[] = {
20139         (char *) "self",(char *) "id",(char *) "enable", NULL
20140     };
20141
20142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_EnableTool",kwnames,&obj0,&obj1,&obj2)) goto fail;
20143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20144     if (SWIG_arg_fail(1)) SWIG_fail;
20145     {
20146         arg2 = (int)(SWIG_As_int(obj1));
20147         if (SWIG_arg_fail(2)) SWIG_fail;
20148     }
20149     {
20150         arg3 = (bool)(SWIG_As_bool(obj2));
20151         if (SWIG_arg_fail(3)) SWIG_fail;
20152     }
20153     {
20154         PyThreadState* __tstate = wxPyBeginAllowThreads();
20155         (arg1)->EnableTool(arg2,arg3);
20156
20157         wxPyEndAllowThreads(__tstate);
20158         if (PyErr_Occurred()) SWIG_fail;
20159     }
20160     Py_INCREF(Py_None); resultobj = Py_None;
20161     return resultobj;
20162     fail:
20163     return NULL;
20164 }
20165
20166
20167 static PyObject *_wrap_ToolBarBase_ToggleTool(PyObject *, PyObject *args, PyObject *kwargs) {
20168     PyObject *resultobj;
20169     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20170     int arg2 ;
20171     bool arg3 ;
20172     PyObject * obj0 = 0 ;
20173     PyObject * obj1 = 0 ;
20174     PyObject * obj2 = 0 ;
20175     char *kwnames[] = {
20176         (char *) "self",(char *) "id",(char *) "toggle", NULL
20177     };
20178
20179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_ToggleTool",kwnames,&obj0,&obj1,&obj2)) goto fail;
20180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20181     if (SWIG_arg_fail(1)) SWIG_fail;
20182     {
20183         arg2 = (int)(SWIG_As_int(obj1));
20184         if (SWIG_arg_fail(2)) SWIG_fail;
20185     }
20186     {
20187         arg3 = (bool)(SWIG_As_bool(obj2));
20188         if (SWIG_arg_fail(3)) SWIG_fail;
20189     }
20190     {
20191         PyThreadState* __tstate = wxPyBeginAllowThreads();
20192         (arg1)->ToggleTool(arg2,arg3);
20193
20194         wxPyEndAllowThreads(__tstate);
20195         if (PyErr_Occurred()) SWIG_fail;
20196     }
20197     Py_INCREF(Py_None); resultobj = Py_None;
20198     return resultobj;
20199     fail:
20200     return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_ToolBarBase_SetToggle(PyObject *, PyObject *args, PyObject *kwargs) {
20205     PyObject *resultobj;
20206     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20207     int arg2 ;
20208     bool arg3 ;
20209     PyObject * obj0 = 0 ;
20210     PyObject * obj1 = 0 ;
20211     PyObject * obj2 = 0 ;
20212     char *kwnames[] = {
20213         (char *) "self",(char *) "id",(char *) "toggle", NULL
20214     };
20215
20216     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToggle",kwnames,&obj0,&obj1,&obj2)) goto fail;
20217     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20218     if (SWIG_arg_fail(1)) SWIG_fail;
20219     {
20220         arg2 = (int)(SWIG_As_int(obj1));
20221         if (SWIG_arg_fail(2)) SWIG_fail;
20222     }
20223     {
20224         arg3 = (bool)(SWIG_As_bool(obj2));
20225         if (SWIG_arg_fail(3)) SWIG_fail;
20226     }
20227     {
20228         PyThreadState* __tstate = wxPyBeginAllowThreads();
20229         (arg1)->SetToggle(arg2,arg3);
20230
20231         wxPyEndAllowThreads(__tstate);
20232         if (PyErr_Occurred()) SWIG_fail;
20233     }
20234     Py_INCREF(Py_None); resultobj = Py_None;
20235     return resultobj;
20236     fail:
20237     return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_ToolBarBase_GetToolClientData(PyObject *, PyObject *args, PyObject *kwargs) {
20242     PyObject *resultobj;
20243     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20244     int arg2 ;
20245     PyObject *result;
20246     PyObject * obj0 = 0 ;
20247     PyObject * obj1 = 0 ;
20248     char *kwnames[] = {
20249         (char *) "self",(char *) "id", NULL
20250     };
20251
20252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolClientData",kwnames,&obj0,&obj1)) goto fail;
20253     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20254     if (SWIG_arg_fail(1)) SWIG_fail;
20255     {
20256         arg2 = (int)(SWIG_As_int(obj1));
20257         if (SWIG_arg_fail(2)) SWIG_fail;
20258     }
20259     {
20260         PyThreadState* __tstate = wxPyBeginAllowThreads();
20261         result = (PyObject *)wxToolBarBase_GetToolClientData(arg1,arg2);
20262
20263         wxPyEndAllowThreads(__tstate);
20264         if (PyErr_Occurred()) SWIG_fail;
20265     }
20266     resultobj = result;
20267     return resultobj;
20268     fail:
20269     return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_ToolBarBase_SetToolClientData(PyObject *, PyObject *args, PyObject *kwargs) {
20274     PyObject *resultobj;
20275     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20276     int arg2 ;
20277     PyObject *arg3 = (PyObject *) 0 ;
20278     PyObject * obj0 = 0 ;
20279     PyObject * obj1 = 0 ;
20280     PyObject * obj2 = 0 ;
20281     char *kwnames[] = {
20282         (char *) "self",(char *) "id",(char *) "clientData", NULL
20283     };
20284
20285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
20286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20287     if (SWIG_arg_fail(1)) SWIG_fail;
20288     {
20289         arg2 = (int)(SWIG_As_int(obj1));
20290         if (SWIG_arg_fail(2)) SWIG_fail;
20291     }
20292     arg3 = obj2;
20293     {
20294         PyThreadState* __tstate = wxPyBeginAllowThreads();
20295         wxToolBarBase_SetToolClientData(arg1,arg2,arg3);
20296
20297         wxPyEndAllowThreads(__tstate);
20298         if (PyErr_Occurred()) SWIG_fail;
20299     }
20300     Py_INCREF(Py_None); resultobj = Py_None;
20301     return resultobj;
20302     fail:
20303     return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_ToolBarBase_GetToolPos(PyObject *, PyObject *args, PyObject *kwargs) {
20308     PyObject *resultobj;
20309     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20310     int arg2 ;
20311     int 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_GetToolPos",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 = (int)((wxToolBarBase const *)arg1)->GetToolPos(arg2);
20328
20329         wxPyEndAllowThreads(__tstate);
20330         if (PyErr_Occurred()) SWIG_fail;
20331     }
20332     {
20333         resultobj = SWIG_From_int((int)(result));
20334     }
20335     return resultobj;
20336     fail:
20337     return NULL;
20338 }
20339
20340
20341 static PyObject *_wrap_ToolBarBase_GetToolState(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_GetToolState",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)->GetToolState(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_GetToolEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20376     PyObject *resultobj;
20377     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20378     int arg2 ;
20379     bool result;
20380     PyObject * obj0 = 0 ;
20381     PyObject * obj1 = 0 ;
20382     char *kwnames[] = {
20383         (char *) "self",(char *) "id", NULL
20384     };
20385
20386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolEnabled",kwnames,&obj0,&obj1)) goto fail;
20387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20388     if (SWIG_arg_fail(1)) SWIG_fail;
20389     {
20390         arg2 = (int)(SWIG_As_int(obj1));
20391         if (SWIG_arg_fail(2)) SWIG_fail;
20392     }
20393     {
20394         PyThreadState* __tstate = wxPyBeginAllowThreads();
20395         result = (bool)(arg1)->GetToolEnabled(arg2);
20396
20397         wxPyEndAllowThreads(__tstate);
20398         if (PyErr_Occurred()) SWIG_fail;
20399     }
20400     {
20401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20402     }
20403     return resultobj;
20404     fail:
20405     return NULL;
20406 }
20407
20408
20409 static PyObject *_wrap_ToolBarBase_SetToolShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20410     PyObject *resultobj;
20411     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20412     int arg2 ;
20413     wxString *arg3 = 0 ;
20414     bool temp3 = false ;
20415     PyObject * obj0 = 0 ;
20416     PyObject * obj1 = 0 ;
20417     PyObject * obj2 = 0 ;
20418     char *kwnames[] = {
20419         (char *) "self",(char *) "id",(char *) "helpString", NULL
20420     };
20421
20422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolShortHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
20423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20424     if (SWIG_arg_fail(1)) SWIG_fail;
20425     {
20426         arg2 = (int)(SWIG_As_int(obj1));
20427         if (SWIG_arg_fail(2)) SWIG_fail;
20428     }
20429     {
20430         arg3 = wxString_in_helper(obj2);
20431         if (arg3 == NULL) SWIG_fail;
20432         temp3 = true;
20433     }
20434     {
20435         PyThreadState* __tstate = wxPyBeginAllowThreads();
20436         (arg1)->SetToolShortHelp(arg2,(wxString const &)*arg3);
20437
20438         wxPyEndAllowThreads(__tstate);
20439         if (PyErr_Occurred()) SWIG_fail;
20440     }
20441     Py_INCREF(Py_None); resultobj = Py_None;
20442     {
20443         if (temp3)
20444         delete arg3;
20445     }
20446     return resultobj;
20447     fail:
20448     {
20449         if (temp3)
20450         delete arg3;
20451     }
20452     return NULL;
20453 }
20454
20455
20456 static PyObject *_wrap_ToolBarBase_GetToolShortHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20457     PyObject *resultobj;
20458     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20459     int arg2 ;
20460     wxString result;
20461     PyObject * obj0 = 0 ;
20462     PyObject * obj1 = 0 ;
20463     char *kwnames[] = {
20464         (char *) "self",(char *) "id", NULL
20465     };
20466
20467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolShortHelp",kwnames,&obj0,&obj1)) goto fail;
20468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20469     if (SWIG_arg_fail(1)) SWIG_fail;
20470     {
20471         arg2 = (int)(SWIG_As_int(obj1));
20472         if (SWIG_arg_fail(2)) SWIG_fail;
20473     }
20474     {
20475         PyThreadState* __tstate = wxPyBeginAllowThreads();
20476         result = (arg1)->GetToolShortHelp(arg2);
20477
20478         wxPyEndAllowThreads(__tstate);
20479         if (PyErr_Occurred()) SWIG_fail;
20480     }
20481     {
20482 #if wxUSE_UNICODE
20483         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20484 #else
20485         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20486 #endif
20487     }
20488     return resultobj;
20489     fail:
20490     return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_ToolBarBase_SetToolLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20495     PyObject *resultobj;
20496     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20497     int arg2 ;
20498     wxString *arg3 = 0 ;
20499     bool temp3 = false ;
20500     PyObject * obj0 = 0 ;
20501     PyObject * obj1 = 0 ;
20502     PyObject * obj2 = 0 ;
20503     char *kwnames[] = {
20504         (char *) "self",(char *) "id",(char *) "helpString", NULL
20505     };
20506
20507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolLongHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
20508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20509     if (SWIG_arg_fail(1)) SWIG_fail;
20510     {
20511         arg2 = (int)(SWIG_As_int(obj1));
20512         if (SWIG_arg_fail(2)) SWIG_fail;
20513     }
20514     {
20515         arg3 = wxString_in_helper(obj2);
20516         if (arg3 == NULL) SWIG_fail;
20517         temp3 = true;
20518     }
20519     {
20520         PyThreadState* __tstate = wxPyBeginAllowThreads();
20521         (arg1)->SetToolLongHelp(arg2,(wxString const &)*arg3);
20522
20523         wxPyEndAllowThreads(__tstate);
20524         if (PyErr_Occurred()) SWIG_fail;
20525     }
20526     Py_INCREF(Py_None); resultobj = Py_None;
20527     {
20528         if (temp3)
20529         delete arg3;
20530     }
20531     return resultobj;
20532     fail:
20533     {
20534         if (temp3)
20535         delete arg3;
20536     }
20537     return NULL;
20538 }
20539
20540
20541 static PyObject *_wrap_ToolBarBase_GetToolLongHelp(PyObject *, PyObject *args, PyObject *kwargs) {
20542     PyObject *resultobj;
20543     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20544     int arg2 ;
20545     wxString result;
20546     PyObject * obj0 = 0 ;
20547     PyObject * obj1 = 0 ;
20548     char *kwnames[] = {
20549         (char *) "self",(char *) "id", NULL
20550     };
20551
20552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolLongHelp",kwnames,&obj0,&obj1)) goto fail;
20553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20554     if (SWIG_arg_fail(1)) SWIG_fail;
20555     {
20556         arg2 = (int)(SWIG_As_int(obj1));
20557         if (SWIG_arg_fail(2)) SWIG_fail;
20558     }
20559     {
20560         PyThreadState* __tstate = wxPyBeginAllowThreads();
20561         result = (arg1)->GetToolLongHelp(arg2);
20562
20563         wxPyEndAllowThreads(__tstate);
20564         if (PyErr_Occurred()) SWIG_fail;
20565     }
20566     {
20567 #if wxUSE_UNICODE
20568         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20569 #else
20570         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20571 #endif
20572     }
20573     return resultobj;
20574     fail:
20575     return NULL;
20576 }
20577
20578
20579 static PyObject *_wrap_ToolBarBase_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
20580     PyObject *resultobj;
20581     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20582     int arg2 ;
20583     int arg3 ;
20584     PyObject * obj0 = 0 ;
20585     PyObject * obj1 = 0 ;
20586     PyObject * obj2 = 0 ;
20587     char *kwnames[] = {
20588         (char *) "self",(char *) "x",(char *) "y", NULL
20589     };
20590
20591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
20592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20593     if (SWIG_arg_fail(1)) SWIG_fail;
20594     {
20595         arg2 = (int)(SWIG_As_int(obj1));
20596         if (SWIG_arg_fail(2)) SWIG_fail;
20597     }
20598     {
20599         arg3 = (int)(SWIG_As_int(obj2));
20600         if (SWIG_arg_fail(3)) SWIG_fail;
20601     }
20602     {
20603         PyThreadState* __tstate = wxPyBeginAllowThreads();
20604         (arg1)->SetMargins(arg2,arg3);
20605
20606         wxPyEndAllowThreads(__tstate);
20607         if (PyErr_Occurred()) SWIG_fail;
20608     }
20609     Py_INCREF(Py_None); resultobj = Py_None;
20610     return resultobj;
20611     fail:
20612     return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_ToolBarBase_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20617     PyObject *resultobj;
20618     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20619     wxSize *arg2 = 0 ;
20620     wxSize temp2 ;
20621     PyObject * obj0 = 0 ;
20622     PyObject * obj1 = 0 ;
20623     char *kwnames[] = {
20624         (char *) "self",(char *) "size", NULL
20625     };
20626
20627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetMargins",kwnames,&obj0,&obj1)) goto fail;
20628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20629     if (SWIG_arg_fail(1)) SWIG_fail;
20630     {
20631         arg2 = &temp2;
20632         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20633     }
20634     {
20635         PyThreadState* __tstate = wxPyBeginAllowThreads();
20636         (arg1)->SetMargins((wxSize const &)*arg2);
20637
20638         wxPyEndAllowThreads(__tstate);
20639         if (PyErr_Occurred()) SWIG_fail;
20640     }
20641     Py_INCREF(Py_None); resultobj = Py_None;
20642     return resultobj;
20643     fail:
20644     return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_ToolBarBase_SetToolPacking(PyObject *, PyObject *args, PyObject *kwargs) {
20649     PyObject *resultobj;
20650     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20651     int arg2 ;
20652     PyObject * obj0 = 0 ;
20653     PyObject * obj1 = 0 ;
20654     char *kwnames[] = {
20655         (char *) "self",(char *) "packing", NULL
20656     };
20657
20658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolPacking",kwnames,&obj0,&obj1)) goto fail;
20659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20660     if (SWIG_arg_fail(1)) SWIG_fail;
20661     {
20662         arg2 = (int)(SWIG_As_int(obj1));
20663         if (SWIG_arg_fail(2)) SWIG_fail;
20664     }
20665     {
20666         PyThreadState* __tstate = wxPyBeginAllowThreads();
20667         (arg1)->SetToolPacking(arg2);
20668
20669         wxPyEndAllowThreads(__tstate);
20670         if (PyErr_Occurred()) SWIG_fail;
20671     }
20672     Py_INCREF(Py_None); resultobj = Py_None;
20673     return resultobj;
20674     fail:
20675     return NULL;
20676 }
20677
20678
20679 static PyObject *_wrap_ToolBarBase_SetToolSeparation(PyObject *, PyObject *args, PyObject *kwargs) {
20680     PyObject *resultobj;
20681     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20682     int arg2 ;
20683     PyObject * obj0 = 0 ;
20684     PyObject * obj1 = 0 ;
20685     char *kwnames[] = {
20686         (char *) "self",(char *) "separation", NULL
20687     };
20688
20689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolSeparation",kwnames,&obj0,&obj1)) goto fail;
20690     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20691     if (SWIG_arg_fail(1)) SWIG_fail;
20692     {
20693         arg2 = (int)(SWIG_As_int(obj1));
20694         if (SWIG_arg_fail(2)) SWIG_fail;
20695     }
20696     {
20697         PyThreadState* __tstate = wxPyBeginAllowThreads();
20698         (arg1)->SetToolSeparation(arg2);
20699
20700         wxPyEndAllowThreads(__tstate);
20701         if (PyErr_Occurred()) SWIG_fail;
20702     }
20703     Py_INCREF(Py_None); resultobj = Py_None;
20704     return resultobj;
20705     fail:
20706     return NULL;
20707 }
20708
20709
20710 static PyObject *_wrap_ToolBarBase_GetToolMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20711     PyObject *resultobj;
20712     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20713     wxSize result;
20714     PyObject * obj0 = 0 ;
20715     char *kwnames[] = {
20716         (char *) "self", NULL
20717     };
20718
20719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolMargins",kwnames,&obj0)) goto fail;
20720     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20721     if (SWIG_arg_fail(1)) SWIG_fail;
20722     {
20723         PyThreadState* __tstate = wxPyBeginAllowThreads();
20724         result = (arg1)->GetToolMargins();
20725
20726         wxPyEndAllowThreads(__tstate);
20727         if (PyErr_Occurred()) SWIG_fail;
20728     }
20729     {
20730         wxSize * resultptr;
20731         resultptr = new wxSize((wxSize &)(result));
20732         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20733     }
20734     return resultobj;
20735     fail:
20736     return NULL;
20737 }
20738
20739
20740 static PyObject *_wrap_ToolBarBase_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
20741     PyObject *resultobj;
20742     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20743     wxSize result;
20744     PyObject * obj0 = 0 ;
20745     char *kwnames[] = {
20746         (char *) "self", NULL
20747     };
20748
20749     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMargins",kwnames,&obj0)) goto fail;
20750     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20751     if (SWIG_arg_fail(1)) SWIG_fail;
20752     {
20753         PyThreadState* __tstate = wxPyBeginAllowThreads();
20754         result = (arg1)->GetMargins();
20755
20756         wxPyEndAllowThreads(__tstate);
20757         if (PyErr_Occurred()) SWIG_fail;
20758     }
20759     {
20760         wxSize * resultptr;
20761         resultptr = new wxSize((wxSize &)(result));
20762         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20763     }
20764     return resultobj;
20765     fail:
20766     return NULL;
20767 }
20768
20769
20770 static PyObject *_wrap_ToolBarBase_GetToolPacking(PyObject *, PyObject *args, PyObject *kwargs) {
20771     PyObject *resultobj;
20772     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20773     int result;
20774     PyObject * obj0 = 0 ;
20775     char *kwnames[] = {
20776         (char *) "self", NULL
20777     };
20778
20779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolPacking",kwnames,&obj0)) goto fail;
20780     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20781     if (SWIG_arg_fail(1)) SWIG_fail;
20782     {
20783         PyThreadState* __tstate = wxPyBeginAllowThreads();
20784         result = (int)(arg1)->GetToolPacking();
20785
20786         wxPyEndAllowThreads(__tstate);
20787         if (PyErr_Occurred()) SWIG_fail;
20788     }
20789     {
20790         resultobj = SWIG_From_int((int)(result));
20791     }
20792     return resultobj;
20793     fail:
20794     return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_ToolBarBase_GetToolSeparation(PyObject *, PyObject *args, PyObject *kwargs) {
20799     PyObject *resultobj;
20800     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20801     int result;
20802     PyObject * obj0 = 0 ;
20803     char *kwnames[] = {
20804         (char *) "self", NULL
20805     };
20806
20807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolSeparation",kwnames,&obj0)) goto fail;
20808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20809     if (SWIG_arg_fail(1)) SWIG_fail;
20810     {
20811         PyThreadState* __tstate = wxPyBeginAllowThreads();
20812         result = (int)(arg1)->GetToolSeparation();
20813
20814         wxPyEndAllowThreads(__tstate);
20815         if (PyErr_Occurred()) SWIG_fail;
20816     }
20817     {
20818         resultobj = SWIG_From_int((int)(result));
20819     }
20820     return resultobj;
20821     fail:
20822     return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_ToolBarBase_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
20827     PyObject *resultobj;
20828     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20829     int arg2 ;
20830     PyObject * obj0 = 0 ;
20831     PyObject * obj1 = 0 ;
20832     char *kwnames[] = {
20833         (char *) "self",(char *) "nRows", NULL
20834     };
20835
20836     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetRows",kwnames,&obj0,&obj1)) goto fail;
20837     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20838     if (SWIG_arg_fail(1)) SWIG_fail;
20839     {
20840         arg2 = (int)(SWIG_As_int(obj1));
20841         if (SWIG_arg_fail(2)) SWIG_fail;
20842     }
20843     {
20844         PyThreadState* __tstate = wxPyBeginAllowThreads();
20845         (arg1)->SetRows(arg2);
20846
20847         wxPyEndAllowThreads(__tstate);
20848         if (PyErr_Occurred()) SWIG_fail;
20849     }
20850     Py_INCREF(Py_None); resultobj = Py_None;
20851     return resultobj;
20852     fail:
20853     return NULL;
20854 }
20855
20856
20857 static PyObject *_wrap_ToolBarBase_SetMaxRowsCols(PyObject *, PyObject *args, PyObject *kwargs) {
20858     PyObject *resultobj;
20859     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20860     int arg2 ;
20861     int arg3 ;
20862     PyObject * obj0 = 0 ;
20863     PyObject * obj1 = 0 ;
20864     PyObject * obj2 = 0 ;
20865     char *kwnames[] = {
20866         (char *) "self",(char *) "rows",(char *) "cols", NULL
20867     };
20868
20869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMaxRowsCols",kwnames,&obj0,&obj1,&obj2)) 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         arg2 = (int)(SWIG_As_int(obj1));
20874         if (SWIG_arg_fail(2)) SWIG_fail;
20875     }
20876     {
20877         arg3 = (int)(SWIG_As_int(obj2));
20878         if (SWIG_arg_fail(3)) SWIG_fail;
20879     }
20880     {
20881         PyThreadState* __tstate = wxPyBeginAllowThreads();
20882         (arg1)->SetMaxRowsCols(arg2,arg3);
20883
20884         wxPyEndAllowThreads(__tstate);
20885         if (PyErr_Occurred()) SWIG_fail;
20886     }
20887     Py_INCREF(Py_None); resultobj = Py_None;
20888     return resultobj;
20889     fail:
20890     return NULL;
20891 }
20892
20893
20894 static PyObject *_wrap_ToolBarBase_GetMaxRows(PyObject *, PyObject *args, PyObject *kwargs) {
20895     PyObject *resultobj;
20896     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20897     int result;
20898     PyObject * obj0 = 0 ;
20899     char *kwnames[] = {
20900         (char *) "self", NULL
20901     };
20902
20903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMaxRows",kwnames,&obj0)) goto fail;
20904     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20905     if (SWIG_arg_fail(1)) SWIG_fail;
20906     {
20907         PyThreadState* __tstate = wxPyBeginAllowThreads();
20908         result = (int)(arg1)->GetMaxRows();
20909
20910         wxPyEndAllowThreads(__tstate);
20911         if (PyErr_Occurred()) SWIG_fail;
20912     }
20913     {
20914         resultobj = SWIG_From_int((int)(result));
20915     }
20916     return resultobj;
20917     fail:
20918     return NULL;
20919 }
20920
20921
20922 static PyObject *_wrap_ToolBarBase_GetMaxCols(PyObject *, PyObject *args, PyObject *kwargs) {
20923     PyObject *resultobj;
20924     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20925     int result;
20926     PyObject * obj0 = 0 ;
20927     char *kwnames[] = {
20928         (char *) "self", NULL
20929     };
20930
20931     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetMaxCols",kwnames,&obj0)) goto fail;
20932     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20933     if (SWIG_arg_fail(1)) SWIG_fail;
20934     {
20935         PyThreadState* __tstate = wxPyBeginAllowThreads();
20936         result = (int)(arg1)->GetMaxCols();
20937
20938         wxPyEndAllowThreads(__tstate);
20939         if (PyErr_Occurred()) SWIG_fail;
20940     }
20941     {
20942         resultobj = SWIG_From_int((int)(result));
20943     }
20944     return resultobj;
20945     fail:
20946     return NULL;
20947 }
20948
20949
20950 static PyObject *_wrap_ToolBarBase_SetToolBitmapSize(PyObject *, PyObject *args, PyObject *kwargs) {
20951     PyObject *resultobj;
20952     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20953     wxSize *arg2 = 0 ;
20954     wxSize temp2 ;
20955     PyObject * obj0 = 0 ;
20956     PyObject * obj1 = 0 ;
20957     char *kwnames[] = {
20958         (char *) "self",(char *) "size", NULL
20959     };
20960
20961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolBitmapSize",kwnames,&obj0,&obj1)) goto fail;
20962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20963     if (SWIG_arg_fail(1)) SWIG_fail;
20964     {
20965         arg2 = &temp2;
20966         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20967     }
20968     {
20969         PyThreadState* __tstate = wxPyBeginAllowThreads();
20970         (arg1)->SetToolBitmapSize((wxSize const &)*arg2);
20971
20972         wxPyEndAllowThreads(__tstate);
20973         if (PyErr_Occurred()) SWIG_fail;
20974     }
20975     Py_INCREF(Py_None); resultobj = Py_None;
20976     return resultobj;
20977     fail:
20978     return NULL;
20979 }
20980
20981
20982 static PyObject *_wrap_ToolBarBase_GetToolBitmapSize(PyObject *, PyObject *args, PyObject *kwargs) {
20983     PyObject *resultobj;
20984     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
20985     wxSize result;
20986     PyObject * obj0 = 0 ;
20987     char *kwnames[] = {
20988         (char *) "self", NULL
20989     };
20990
20991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolBitmapSize",kwnames,&obj0)) goto fail;
20992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
20993     if (SWIG_arg_fail(1)) SWIG_fail;
20994     {
20995         PyThreadState* __tstate = wxPyBeginAllowThreads();
20996         result = (arg1)->GetToolBitmapSize();
20997
20998         wxPyEndAllowThreads(__tstate);
20999         if (PyErr_Occurred()) SWIG_fail;
21000     }
21001     {
21002         wxSize * resultptr;
21003         resultptr = new wxSize((wxSize &)(result));
21004         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
21005     }
21006     return resultobj;
21007     fail:
21008     return NULL;
21009 }
21010
21011
21012 static PyObject *_wrap_ToolBarBase_GetToolSize(PyObject *, PyObject *args, PyObject *kwargs) {
21013     PyObject *resultobj;
21014     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21015     wxSize result;
21016     PyObject * obj0 = 0 ;
21017     char *kwnames[] = {
21018         (char *) "self", NULL
21019     };
21020
21021     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_GetToolSize",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
21026         result = (arg1)->GetToolSize();
21027
21028         wxPyEndAllowThreads(__tstate);
21029         if (PyErr_Occurred()) SWIG_fail;
21030     }
21031     {
21032         wxSize * resultptr;
21033         resultptr = new wxSize((wxSize &)(result));
21034         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
21035     }
21036     return resultobj;
21037     fail:
21038     return NULL;
21039 }
21040
21041
21042 static PyObject *_wrap_ToolBarBase_FindToolForPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21043     PyObject *resultobj;
21044     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21045     int arg2 ;
21046     int arg3 ;
21047     wxToolBarToolBase *result;
21048     PyObject * obj0 = 0 ;
21049     PyObject * obj1 = 0 ;
21050     PyObject * obj2 = 0 ;
21051     char *kwnames[] = {
21052         (char *) "self",(char *) "x",(char *) "y", NULL
21053     };
21054
21055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_FindToolForPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
21056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21057     if (SWIG_arg_fail(1)) SWIG_fail;
21058     {
21059         arg2 = (int)(SWIG_As_int(obj1));
21060         if (SWIG_arg_fail(2)) SWIG_fail;
21061     }
21062     {
21063         arg3 = (int)(SWIG_As_int(obj2));
21064         if (SWIG_arg_fail(3)) SWIG_fail;
21065     }
21066     {
21067         PyThreadState* __tstate = wxPyBeginAllowThreads();
21068         result = (wxToolBarToolBase *)(arg1)->FindToolForPosition(arg2,arg3);
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_FindById(PyObject *, PyObject *args, PyObject *kwargs) {
21083     PyObject *resultobj;
21084     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21085     int arg2 ;
21086     wxToolBarToolBase *result;
21087     PyObject * obj0 = 0 ;
21088     PyObject * obj1 = 0 ;
21089     char *kwnames[] = {
21090         (char *) "self",(char *) "toolid", NULL
21091     };
21092
21093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindById",kwnames,&obj0,&obj1)) goto fail;
21094     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21095     if (SWIG_arg_fail(1)) SWIG_fail;
21096     {
21097         arg2 = (int)(SWIG_As_int(obj1));
21098         if (SWIG_arg_fail(2)) SWIG_fail;
21099     }
21100     {
21101         PyThreadState* __tstate = wxPyBeginAllowThreads();
21102         result = (wxToolBarToolBase *)((wxToolBarBase const *)arg1)->FindById(arg2);
21103
21104         wxPyEndAllowThreads(__tstate);
21105         if (PyErr_Occurred()) SWIG_fail;
21106     }
21107     {
21108         resultobj = wxPyMake_wxObject(result, 0);
21109     }
21110     return resultobj;
21111     fail:
21112     return NULL;
21113 }
21114
21115
21116 static PyObject *_wrap_ToolBarBase_IsVertical(PyObject *, PyObject *args, PyObject *kwargs) {
21117     PyObject *resultobj;
21118     wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
21119     bool result;
21120     PyObject * obj0 = 0 ;
21121     char *kwnames[] = {
21122         (char *) "self", NULL
21123     };
21124
21125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolBarBase_IsVertical",kwnames,&obj0)) goto fail;
21126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBarBase, SWIG_POINTER_EXCEPTION | 0);
21127     if (SWIG_arg_fail(1)) SWIG_fail;
21128     {
21129         PyThreadState* __tstate = wxPyBeginAllowThreads();
21130         result = (bool)(arg1)->IsVertical();
21131
21132         wxPyEndAllowThreads(__tstate);
21133         if (PyErr_Occurred()) SWIG_fail;
21134     }
21135     {
21136         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21137     }
21138     return resultobj;
21139     fail:
21140     return NULL;
21141 }
21142
21143
21144 static PyObject * ToolBarBase_swigregister(PyObject *, PyObject *args) {
21145     PyObject *obj;
21146     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21147     SWIG_TypeClientData(SWIGTYPE_p_wxToolBarBase, obj);
21148     Py_INCREF(obj);
21149     return Py_BuildValue((char *)"");
21150 }
21151 static PyObject *_wrap_new_ToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
21152     PyObject *resultobj;
21153     wxWindow *arg1 = (wxWindow *) 0 ;
21154     int arg2 = (int) -1 ;
21155     wxPoint const &arg3_defvalue = wxDefaultPosition ;
21156     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21157     wxSize const &arg4_defvalue = wxDefaultSize ;
21158     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
21159     long arg5 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
21160     wxString const &arg6_defvalue = wxPyToolBarNameStr ;
21161     wxString *arg6 = (wxString *) &arg6_defvalue ;
21162     wxToolBar *result;
21163     wxPoint temp3 ;
21164     wxSize temp4 ;
21165     bool temp6 = false ;
21166     PyObject * obj0 = 0 ;
21167     PyObject * obj1 = 0 ;
21168     PyObject * obj2 = 0 ;
21169     PyObject * obj3 = 0 ;
21170     PyObject * obj4 = 0 ;
21171     PyObject * obj5 = 0 ;
21172     char *kwnames[] = {
21173         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
21174     };
21175
21176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ToolBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21178     if (SWIG_arg_fail(1)) SWIG_fail;
21179     if (obj1) {
21180         {
21181             arg2 = (int)(SWIG_As_int(obj1));
21182             if (SWIG_arg_fail(2)) SWIG_fail;
21183         }
21184     }
21185     if (obj2) {
21186         {
21187             arg3 = &temp3;
21188             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21189         }
21190     }
21191     if (obj3) {
21192         {
21193             arg4 = &temp4;
21194             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21195         }
21196     }
21197     if (obj4) {
21198         {
21199             arg5 = (long)(SWIG_As_long(obj4));
21200             if (SWIG_arg_fail(5)) SWIG_fail;
21201         }
21202     }
21203     if (obj5) {
21204         {
21205             arg6 = wxString_in_helper(obj5);
21206             if (arg6 == NULL) SWIG_fail;
21207             temp6 = true;
21208         }
21209     }
21210     {
21211         if (!wxPyCheckForApp()) SWIG_fail;
21212         PyThreadState* __tstate = wxPyBeginAllowThreads();
21213         result = (wxToolBar *)new wxToolBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
21214
21215         wxPyEndAllowThreads(__tstate);
21216         if (PyErr_Occurred()) SWIG_fail;
21217     }
21218     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolBar, 1);
21219     {
21220         if (temp6)
21221         delete arg6;
21222     }
21223     return resultobj;
21224     fail:
21225     {
21226         if (temp6)
21227         delete arg6;
21228     }
21229     return NULL;
21230 }
21231
21232
21233 static PyObject *_wrap_new_PreToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
21234     PyObject *resultobj;
21235     wxToolBar *result;
21236     char *kwnames[] = {
21237         NULL
21238     };
21239
21240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreToolBar",kwnames)) goto fail;
21241     {
21242         if (!wxPyCheckForApp()) SWIG_fail;
21243         PyThreadState* __tstate = wxPyBeginAllowThreads();
21244         result = (wxToolBar *)new wxToolBar();
21245
21246         wxPyEndAllowThreads(__tstate);
21247         if (PyErr_Occurred()) SWIG_fail;
21248     }
21249     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolBar, 1);
21250     return resultobj;
21251     fail:
21252     return NULL;
21253 }
21254
21255
21256 static PyObject *_wrap_ToolBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
21257     PyObject *resultobj;
21258     wxToolBar *arg1 = (wxToolBar *) 0 ;
21259     wxWindow *arg2 = (wxWindow *) 0 ;
21260     int arg3 = (int) -1 ;
21261     wxPoint const &arg4_defvalue = wxDefaultPosition ;
21262     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
21263     wxSize const &arg5_defvalue = wxDefaultSize ;
21264     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
21265     long arg6 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
21266     wxString const &arg7_defvalue = wxPyToolBarNameStr ;
21267     wxString *arg7 = (wxString *) &arg7_defvalue ;
21268     bool result;
21269     wxPoint temp4 ;
21270     wxSize temp5 ;
21271     bool temp7 = false ;
21272     PyObject * obj0 = 0 ;
21273     PyObject * obj1 = 0 ;
21274     PyObject * obj2 = 0 ;
21275     PyObject * obj3 = 0 ;
21276     PyObject * obj4 = 0 ;
21277     PyObject * obj5 = 0 ;
21278     PyObject * obj6 = 0 ;
21279     char *kwnames[] = {
21280         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
21281     };
21282
21283     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ToolBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21284     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
21285     if (SWIG_arg_fail(1)) SWIG_fail;
21286     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21287     if (SWIG_arg_fail(2)) SWIG_fail;
21288     if (obj2) {
21289         {
21290             arg3 = (int)(SWIG_As_int(obj2));
21291             if (SWIG_arg_fail(3)) SWIG_fail;
21292         }
21293     }
21294     if (obj3) {
21295         {
21296             arg4 = &temp4;
21297             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
21298         }
21299     }
21300     if (obj4) {
21301         {
21302             arg5 = &temp5;
21303             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
21304         }
21305     }
21306     if (obj5) {
21307         {
21308             arg6 = (long)(SWIG_As_long(obj5));
21309             if (SWIG_arg_fail(6)) SWIG_fail;
21310         }
21311     }
21312     if (obj6) {
21313         {
21314             arg7 = wxString_in_helper(obj6);
21315             if (arg7 == NULL) SWIG_fail;
21316             temp7 = true;
21317         }
21318     }
21319     {
21320         PyThreadState* __tstate = wxPyBeginAllowThreads();
21321         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
21322
21323         wxPyEndAllowThreads(__tstate);
21324         if (PyErr_Occurred()) SWIG_fail;
21325     }
21326     {
21327         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21328     }
21329     {
21330         if (temp7)
21331         delete arg7;
21332     }
21333     return resultobj;
21334     fail:
21335     {
21336         if (temp7)
21337         delete arg7;
21338     }
21339     return NULL;
21340 }
21341
21342
21343 static PyObject *_wrap_ToolBar_FindToolForPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21344     PyObject *resultobj;
21345     wxToolBar *arg1 = (wxToolBar *) 0 ;
21346     int arg2 ;
21347     int arg3 ;
21348     wxToolBarToolBase *result;
21349     PyObject * obj0 = 0 ;
21350     PyObject * obj1 = 0 ;
21351     PyObject * obj2 = 0 ;
21352     char *kwnames[] = {
21353         (char *) "self",(char *) "x",(char *) "y", NULL
21354     };
21355
21356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBar_FindToolForPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
21357     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
21358     if (SWIG_arg_fail(1)) SWIG_fail;
21359     {
21360         arg2 = (int)(SWIG_As_int(obj1));
21361         if (SWIG_arg_fail(2)) SWIG_fail;
21362     }
21363     {
21364         arg3 = (int)(SWIG_As_int(obj2));
21365         if (SWIG_arg_fail(3)) SWIG_fail;
21366     }
21367     {
21368         PyThreadState* __tstate = wxPyBeginAllowThreads();
21369         result = (wxToolBarToolBase *)(arg1)->FindToolForPosition(arg2,arg3);
21370
21371         wxPyEndAllowThreads(__tstate);
21372         if (PyErr_Occurred()) SWIG_fail;
21373     }
21374     {
21375         resultobj = wxPyMake_wxObject(result, 0);
21376     }
21377     return resultobj;
21378     fail:
21379     return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_ToolBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
21384     PyObject *resultobj;
21385     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
21386     wxVisualAttributes result;
21387     PyObject * obj0 = 0 ;
21388     char *kwnames[] = {
21389         (char *) "variant", NULL
21390     };
21391
21392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToolBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
21393     if (obj0) {
21394         {
21395             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
21396             if (SWIG_arg_fail(1)) SWIG_fail;
21397         }
21398     }
21399     {
21400         if (!wxPyCheckForApp()) SWIG_fail;
21401         PyThreadState* __tstate = wxPyBeginAllowThreads();
21402         result = wxToolBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
21403
21404         wxPyEndAllowThreads(__tstate);
21405         if (PyErr_Occurred()) SWIG_fail;
21406     }
21407     {
21408         wxVisualAttributes * resultptr;
21409         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
21410         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
21411     }
21412     return resultobj;
21413     fail:
21414     return NULL;
21415 }
21416
21417
21418 static PyObject * ToolBar_swigregister(PyObject *, PyObject *args) {
21419     PyObject *obj;
21420     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21421     SWIG_TypeClientData(SWIGTYPE_p_wxToolBar, obj);
21422     Py_INCREF(obj);
21423     return Py_BuildValue((char *)"");
21424 }
21425 static int _wrap_ListCtrlNameStr_set(PyObject *) {
21426     PyErr_SetString(PyExc_TypeError,"Variable ListCtrlNameStr is read-only.");
21427     return 1;
21428 }
21429
21430
21431 static PyObject *_wrap_ListCtrlNameStr_get(void) {
21432     PyObject *pyobj;
21433
21434     {
21435 #if wxUSE_UNICODE
21436         pyobj = PyUnicode_FromWideChar((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
21437 #else
21438         pyobj = PyString_FromStringAndSize((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
21439 #endif
21440     }
21441     return pyobj;
21442 }
21443
21444
21445 static PyObject *_wrap_new_ListItemAttr(PyObject *, PyObject *args, PyObject *kwargs) {
21446     PyObject *resultobj;
21447     wxColour const &arg1_defvalue = wxNullColour ;
21448     wxColour *arg1 = (wxColour *) &arg1_defvalue ;
21449     wxColour const &arg2_defvalue = wxNullColour ;
21450     wxColour *arg2 = (wxColour *) &arg2_defvalue ;
21451     wxFont const &arg3_defvalue = wxNullFont ;
21452     wxFont *arg3 = (wxFont *) &arg3_defvalue ;
21453     wxListItemAttr *result;
21454     wxColour temp1 ;
21455     wxColour temp2 ;
21456     PyObject * obj0 = 0 ;
21457     PyObject * obj1 = 0 ;
21458     PyObject * obj2 = 0 ;
21459     char *kwnames[] = {
21460         (char *) "colText",(char *) "colBack",(char *) "font", NULL
21461     };
21462
21463     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ListItemAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
21464     if (obj0) {
21465         {
21466             arg1 = &temp1;
21467             if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
21468         }
21469     }
21470     if (obj1) {
21471         {
21472             arg2 = &temp2;
21473             if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21474         }
21475     }
21476     if (obj2) {
21477         {
21478             SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
21479             if (SWIG_arg_fail(3)) SWIG_fail;
21480             if (arg3 == NULL) {
21481                 SWIG_null_ref("wxFont");
21482             }
21483             if (SWIG_arg_fail(3)) SWIG_fail;
21484         }
21485     }
21486     {
21487         PyThreadState* __tstate = wxPyBeginAllowThreads();
21488         result = (wxListItemAttr *)new wxListItemAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3);
21489
21490         wxPyEndAllowThreads(__tstate);
21491         if (PyErr_Occurred()) SWIG_fail;
21492     }
21493     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItemAttr, 1);
21494     return resultobj;
21495     fail:
21496     return NULL;
21497 }
21498
21499
21500 static PyObject *_wrap_ListItemAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21501     PyObject *resultobj;
21502     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21503     wxColour *arg2 = 0 ;
21504     wxColour temp2 ;
21505     PyObject * obj0 = 0 ;
21506     PyObject * obj1 = 0 ;
21507     char *kwnames[] = {
21508         (char *) "self",(char *) "colText", NULL
21509     };
21510
21511     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
21512     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21513     if (SWIG_arg_fail(1)) SWIG_fail;
21514     {
21515         arg2 = &temp2;
21516         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21517     }
21518     {
21519         PyThreadState* __tstate = wxPyBeginAllowThreads();
21520         (arg1)->SetTextColour((wxColour const &)*arg2);
21521
21522         wxPyEndAllowThreads(__tstate);
21523         if (PyErr_Occurred()) SWIG_fail;
21524     }
21525     Py_INCREF(Py_None); resultobj = Py_None;
21526     return resultobj;
21527     fail:
21528     return NULL;
21529 }
21530
21531
21532 static PyObject *_wrap_ListItemAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21533     PyObject *resultobj;
21534     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21535     wxColour *arg2 = 0 ;
21536     wxColour temp2 ;
21537     PyObject * obj0 = 0 ;
21538     PyObject * obj1 = 0 ;
21539     char *kwnames[] = {
21540         (char *) "self",(char *) "colBack", NULL
21541     };
21542
21543     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
21544     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21545     if (SWIG_arg_fail(1)) SWIG_fail;
21546     {
21547         arg2 = &temp2;
21548         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21549     }
21550     {
21551         PyThreadState* __tstate = wxPyBeginAllowThreads();
21552         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
21553
21554         wxPyEndAllowThreads(__tstate);
21555         if (PyErr_Occurred()) SWIG_fail;
21556     }
21557     Py_INCREF(Py_None); resultobj = Py_None;
21558     return resultobj;
21559     fail:
21560     return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_ListItemAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
21565     PyObject *resultobj;
21566     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21567     wxFont *arg2 = 0 ;
21568     PyObject * obj0 = 0 ;
21569     PyObject * obj1 = 0 ;
21570     char *kwnames[] = {
21571         (char *) "self",(char *) "font", NULL
21572     };
21573
21574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetFont",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
21579         if (SWIG_arg_fail(2)) SWIG_fail;
21580         if (arg2 == NULL) {
21581             SWIG_null_ref("wxFont");
21582         }
21583         if (SWIG_arg_fail(2)) SWIG_fail;
21584     }
21585     {
21586         PyThreadState* __tstate = wxPyBeginAllowThreads();
21587         (arg1)->SetFont((wxFont const &)*arg2);
21588
21589         wxPyEndAllowThreads(__tstate);
21590         if (PyErr_Occurred()) SWIG_fail;
21591     }
21592     Py_INCREF(Py_None); resultobj = Py_None;
21593     return resultobj;
21594     fail:
21595     return NULL;
21596 }
21597
21598
21599 static PyObject *_wrap_ListItemAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21600     PyObject *resultobj;
21601     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21602     bool result;
21603     PyObject * obj0 = 0 ;
21604     char *kwnames[] = {
21605         (char *) "self", NULL
21606     };
21607
21608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasTextColour",kwnames,&obj0)) goto fail;
21609     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21610     if (SWIG_arg_fail(1)) SWIG_fail;
21611     {
21612         PyThreadState* __tstate = wxPyBeginAllowThreads();
21613         result = (bool)(arg1)->HasTextColour();
21614
21615         wxPyEndAllowThreads(__tstate);
21616         if (PyErr_Occurred()) SWIG_fail;
21617     }
21618     {
21619         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21620     }
21621     return resultobj;
21622     fail:
21623     return NULL;
21624 }
21625
21626
21627 static PyObject *_wrap_ListItemAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21628     PyObject *resultobj;
21629     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21630     bool result;
21631     PyObject * obj0 = 0 ;
21632     char *kwnames[] = {
21633         (char *) "self", NULL
21634     };
21635
21636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
21637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21638     if (SWIG_arg_fail(1)) SWIG_fail;
21639     {
21640         PyThreadState* __tstate = wxPyBeginAllowThreads();
21641         result = (bool)(arg1)->HasBackgroundColour();
21642
21643         wxPyEndAllowThreads(__tstate);
21644         if (PyErr_Occurred()) SWIG_fail;
21645     }
21646     {
21647         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21648     }
21649     return resultobj;
21650     fail:
21651     return NULL;
21652 }
21653
21654
21655 static PyObject *_wrap_ListItemAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
21656     PyObject *resultobj;
21657     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21658     bool result;
21659     PyObject * obj0 = 0 ;
21660     char *kwnames[] = {
21661         (char *) "self", NULL
21662     };
21663
21664     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_HasFont",kwnames,&obj0)) goto fail;
21665     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21666     if (SWIG_arg_fail(1)) SWIG_fail;
21667     {
21668         PyThreadState* __tstate = wxPyBeginAllowThreads();
21669         result = (bool)(arg1)->HasFont();
21670
21671         wxPyEndAllowThreads(__tstate);
21672         if (PyErr_Occurred()) SWIG_fail;
21673     }
21674     {
21675         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21676     }
21677     return resultobj;
21678     fail:
21679     return NULL;
21680 }
21681
21682
21683 static PyObject *_wrap_ListItemAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
21684     PyObject *resultobj;
21685     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21686     wxColour result;
21687     PyObject * obj0 = 0 ;
21688     char *kwnames[] = {
21689         (char *) "self", NULL
21690     };
21691
21692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetTextColour",kwnames,&obj0)) goto fail;
21693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21694     if (SWIG_arg_fail(1)) SWIG_fail;
21695     {
21696         PyThreadState* __tstate = wxPyBeginAllowThreads();
21697         result = (arg1)->GetTextColour();
21698
21699         wxPyEndAllowThreads(__tstate);
21700         if (PyErr_Occurred()) SWIG_fail;
21701     }
21702     {
21703         wxColour * resultptr;
21704         resultptr = new wxColour((wxColour &)(result));
21705         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21706     }
21707     return resultobj;
21708     fail:
21709     return NULL;
21710 }
21711
21712
21713 static PyObject *_wrap_ListItemAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
21714     PyObject *resultobj;
21715     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21716     wxColour result;
21717     PyObject * obj0 = 0 ;
21718     char *kwnames[] = {
21719         (char *) "self", NULL
21720     };
21721
21722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
21723     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21724     if (SWIG_arg_fail(1)) SWIG_fail;
21725     {
21726         PyThreadState* __tstate = wxPyBeginAllowThreads();
21727         result = (arg1)->GetBackgroundColour();
21728
21729         wxPyEndAllowThreads(__tstate);
21730         if (PyErr_Occurred()) SWIG_fail;
21731     }
21732     {
21733         wxColour * resultptr;
21734         resultptr = new wxColour((wxColour &)(result));
21735         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21736     }
21737     return resultobj;
21738     fail:
21739     return NULL;
21740 }
21741
21742
21743 static PyObject *_wrap_ListItemAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
21744     PyObject *resultobj;
21745     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21746     wxFont result;
21747     PyObject * obj0 = 0 ;
21748     char *kwnames[] = {
21749         (char *) "self", NULL
21750     };
21751
21752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_GetFont",kwnames,&obj0)) goto fail;
21753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21754     if (SWIG_arg_fail(1)) SWIG_fail;
21755     {
21756         PyThreadState* __tstate = wxPyBeginAllowThreads();
21757         result = (arg1)->GetFont();
21758
21759         wxPyEndAllowThreads(__tstate);
21760         if (PyErr_Occurred()) SWIG_fail;
21761     }
21762     {
21763         wxFont * resultptr;
21764         resultptr = new wxFont((wxFont &)(result));
21765         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
21766     }
21767     return resultobj;
21768     fail:
21769     return NULL;
21770 }
21771
21772
21773 static PyObject *_wrap_ListItemAttr_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
21774     PyObject *resultobj;
21775     wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
21776     PyObject * obj0 = 0 ;
21777     char *kwnames[] = {
21778         (char *) "self", NULL
21779     };
21780
21781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItemAttr_Destroy",kwnames,&obj0)) goto fail;
21782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_EXCEPTION | 0);
21783     if (SWIG_arg_fail(1)) SWIG_fail;
21784     {
21785         PyThreadState* __tstate = wxPyBeginAllowThreads();
21786         wxListItemAttr_Destroy(arg1);
21787
21788         wxPyEndAllowThreads(__tstate);
21789         if (PyErr_Occurred()) SWIG_fail;
21790     }
21791     Py_INCREF(Py_None); resultobj = Py_None;
21792     return resultobj;
21793     fail:
21794     return NULL;
21795 }
21796
21797
21798 static PyObject * ListItemAttr_swigregister(PyObject *, PyObject *args) {
21799     PyObject *obj;
21800     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21801     SWIG_TypeClientData(SWIGTYPE_p_wxListItemAttr, obj);
21802     Py_INCREF(obj);
21803     return Py_BuildValue((char *)"");
21804 }
21805 static PyObject *_wrap_new_ListItem(PyObject *, PyObject *args, PyObject *kwargs) {
21806     PyObject *resultobj;
21807     wxListItem *result;
21808     char *kwnames[] = {
21809         NULL
21810     };
21811
21812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ListItem",kwnames)) goto fail;
21813     {
21814         PyThreadState* __tstate = wxPyBeginAllowThreads();
21815         result = (wxListItem *)new wxListItem();
21816
21817         wxPyEndAllowThreads(__tstate);
21818         if (PyErr_Occurred()) SWIG_fail;
21819     }
21820     {
21821         resultobj = wxPyMake_wxObject(result, 1);
21822     }
21823     return resultobj;
21824     fail:
21825     return NULL;
21826 }
21827
21828
21829 static PyObject *_wrap_delete_ListItem(PyObject *, PyObject *args, PyObject *kwargs) {
21830     PyObject *resultobj;
21831     wxListItem *arg1 = (wxListItem *) 0 ;
21832     PyObject * obj0 = 0 ;
21833     char *kwnames[] = {
21834         (char *) "self", NULL
21835     };
21836
21837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ListItem",kwnames,&obj0)) goto fail;
21838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21839     if (SWIG_arg_fail(1)) SWIG_fail;
21840     {
21841         PyThreadState* __tstate = wxPyBeginAllowThreads();
21842         delete arg1;
21843
21844         wxPyEndAllowThreads(__tstate);
21845         if (PyErr_Occurred()) SWIG_fail;
21846     }
21847     Py_INCREF(Py_None); resultobj = Py_None;
21848     return resultobj;
21849     fail:
21850     return NULL;
21851 }
21852
21853
21854 static PyObject *_wrap_ListItem_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
21855     PyObject *resultobj;
21856     wxListItem *arg1 = (wxListItem *) 0 ;
21857     PyObject * obj0 = 0 ;
21858     char *kwnames[] = {
21859         (char *) "self", NULL
21860     };
21861
21862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_Clear",kwnames,&obj0)) goto fail;
21863     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21864     if (SWIG_arg_fail(1)) SWIG_fail;
21865     {
21866         PyThreadState* __tstate = wxPyBeginAllowThreads();
21867         (arg1)->Clear();
21868
21869         wxPyEndAllowThreads(__tstate);
21870         if (PyErr_Occurred()) SWIG_fail;
21871     }
21872     Py_INCREF(Py_None); resultobj = Py_None;
21873     return resultobj;
21874     fail:
21875     return NULL;
21876 }
21877
21878
21879 static PyObject *_wrap_ListItem_ClearAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
21880     PyObject *resultobj;
21881     wxListItem *arg1 = (wxListItem *) 0 ;
21882     PyObject * obj0 = 0 ;
21883     char *kwnames[] = {
21884         (char *) "self", NULL
21885     };
21886
21887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_ClearAttributes",kwnames,&obj0)) goto fail;
21888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21889     if (SWIG_arg_fail(1)) SWIG_fail;
21890     {
21891         PyThreadState* __tstate = wxPyBeginAllowThreads();
21892         (arg1)->ClearAttributes();
21893
21894         wxPyEndAllowThreads(__tstate);
21895         if (PyErr_Occurred()) SWIG_fail;
21896     }
21897     Py_INCREF(Py_None); resultobj = Py_None;
21898     return resultobj;
21899     fail:
21900     return NULL;
21901 }
21902
21903
21904 static PyObject *_wrap_ListItem_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
21905     PyObject *resultobj;
21906     wxListItem *arg1 = (wxListItem *) 0 ;
21907     long arg2 ;
21908     PyObject * obj0 = 0 ;
21909     PyObject * obj1 = 0 ;
21910     char *kwnames[] = {
21911         (char *) "self",(char *) "mask", NULL
21912     };
21913
21914     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetMask",kwnames,&obj0,&obj1)) goto fail;
21915     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21916     if (SWIG_arg_fail(1)) SWIG_fail;
21917     {
21918         arg2 = (long)(SWIG_As_long(obj1));
21919         if (SWIG_arg_fail(2)) SWIG_fail;
21920     }
21921     {
21922         PyThreadState* __tstate = wxPyBeginAllowThreads();
21923         (arg1)->SetMask(arg2);
21924
21925         wxPyEndAllowThreads(__tstate);
21926         if (PyErr_Occurred()) SWIG_fail;
21927     }
21928     Py_INCREF(Py_None); resultobj = Py_None;
21929     return resultobj;
21930     fail:
21931     return NULL;
21932 }
21933
21934
21935 static PyObject *_wrap_ListItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
21936     PyObject *resultobj;
21937     wxListItem *arg1 = (wxListItem *) 0 ;
21938     long arg2 ;
21939     PyObject * obj0 = 0 ;
21940     PyObject * obj1 = 0 ;
21941     char *kwnames[] = {
21942         (char *) "self",(char *) "id", NULL
21943     };
21944
21945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetId",kwnames,&obj0,&obj1)) goto fail;
21946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21947     if (SWIG_arg_fail(1)) SWIG_fail;
21948     {
21949         arg2 = (long)(SWIG_As_long(obj1));
21950         if (SWIG_arg_fail(2)) SWIG_fail;
21951     }
21952     {
21953         PyThreadState* __tstate = wxPyBeginAllowThreads();
21954         (arg1)->SetId(arg2);
21955
21956         wxPyEndAllowThreads(__tstate);
21957         if (PyErr_Occurred()) SWIG_fail;
21958     }
21959     Py_INCREF(Py_None); resultobj = Py_None;
21960     return resultobj;
21961     fail:
21962     return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_ListItem_SetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
21967     PyObject *resultobj;
21968     wxListItem *arg1 = (wxListItem *) 0 ;
21969     int arg2 ;
21970     PyObject * obj0 = 0 ;
21971     PyObject * obj1 = 0 ;
21972     char *kwnames[] = {
21973         (char *) "self",(char *) "col", NULL
21974     };
21975
21976     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetColumn",kwnames,&obj0,&obj1)) goto fail;
21977     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
21978     if (SWIG_arg_fail(1)) SWIG_fail;
21979     {
21980         arg2 = (int)(SWIG_As_int(obj1));
21981         if (SWIG_arg_fail(2)) SWIG_fail;
21982     }
21983     {
21984         PyThreadState* __tstate = wxPyBeginAllowThreads();
21985         (arg1)->SetColumn(arg2);
21986
21987         wxPyEndAllowThreads(__tstate);
21988         if (PyErr_Occurred()) SWIG_fail;
21989     }
21990     Py_INCREF(Py_None); resultobj = Py_None;
21991     return resultobj;
21992     fail:
21993     return NULL;
21994 }
21995
21996
21997 static PyObject *_wrap_ListItem_SetState(PyObject *, PyObject *args, PyObject *kwargs) {
21998     PyObject *resultobj;
21999     wxListItem *arg1 = (wxListItem *) 0 ;
22000     long arg2 ;
22001     PyObject * obj0 = 0 ;
22002     PyObject * obj1 = 0 ;
22003     char *kwnames[] = {
22004         (char *) "self",(char *) "state", NULL
22005     };
22006
22007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetState",kwnames,&obj0,&obj1)) goto fail;
22008     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22009     if (SWIG_arg_fail(1)) SWIG_fail;
22010     {
22011         arg2 = (long)(SWIG_As_long(obj1));
22012         if (SWIG_arg_fail(2)) SWIG_fail;
22013     }
22014     {
22015         PyThreadState* __tstate = wxPyBeginAllowThreads();
22016         (arg1)->SetState(arg2);
22017
22018         wxPyEndAllowThreads(__tstate);
22019         if (PyErr_Occurred()) SWIG_fail;
22020     }
22021     Py_INCREF(Py_None); resultobj = Py_None;
22022     return resultobj;
22023     fail:
22024     return NULL;
22025 }
22026
22027
22028 static PyObject *_wrap_ListItem_SetStateMask(PyObject *, PyObject *args, PyObject *kwargs) {
22029     PyObject *resultobj;
22030     wxListItem *arg1 = (wxListItem *) 0 ;
22031     long arg2 ;
22032     PyObject * obj0 = 0 ;
22033     PyObject * obj1 = 0 ;
22034     char *kwnames[] = {
22035         (char *) "self",(char *) "stateMask", NULL
22036     };
22037
22038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetStateMask",kwnames,&obj0,&obj1)) goto fail;
22039     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22040     if (SWIG_arg_fail(1)) SWIG_fail;
22041     {
22042         arg2 = (long)(SWIG_As_long(obj1));
22043         if (SWIG_arg_fail(2)) SWIG_fail;
22044     }
22045     {
22046         PyThreadState* __tstate = wxPyBeginAllowThreads();
22047         (arg1)->SetStateMask(arg2);
22048
22049         wxPyEndAllowThreads(__tstate);
22050         if (PyErr_Occurred()) SWIG_fail;
22051     }
22052     Py_INCREF(Py_None); resultobj = Py_None;
22053     return resultobj;
22054     fail:
22055     return NULL;
22056 }
22057
22058
22059 static PyObject *_wrap_ListItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
22060     PyObject *resultobj;
22061     wxListItem *arg1 = (wxListItem *) 0 ;
22062     wxString *arg2 = 0 ;
22063     bool temp2 = false ;
22064     PyObject * obj0 = 0 ;
22065     PyObject * obj1 = 0 ;
22066     char *kwnames[] = {
22067         (char *) "self",(char *) "text", NULL
22068     };
22069
22070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetText",kwnames,&obj0,&obj1)) goto fail;
22071     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22072     if (SWIG_arg_fail(1)) SWIG_fail;
22073     {
22074         arg2 = wxString_in_helper(obj1);
22075         if (arg2 == NULL) SWIG_fail;
22076         temp2 = true;
22077     }
22078     {
22079         PyThreadState* __tstate = wxPyBeginAllowThreads();
22080         (arg1)->SetText((wxString const &)*arg2);
22081
22082         wxPyEndAllowThreads(__tstate);
22083         if (PyErr_Occurred()) SWIG_fail;
22084     }
22085     Py_INCREF(Py_None); resultobj = Py_None;
22086     {
22087         if (temp2)
22088         delete arg2;
22089     }
22090     return resultobj;
22091     fail:
22092     {
22093         if (temp2)
22094         delete arg2;
22095     }
22096     return NULL;
22097 }
22098
22099
22100 static PyObject *_wrap_ListItem_SetImage(PyObject *, PyObject *args, PyObject *kwargs) {
22101     PyObject *resultobj;
22102     wxListItem *arg1 = (wxListItem *) 0 ;
22103     int arg2 ;
22104     PyObject * obj0 = 0 ;
22105     PyObject * obj1 = 0 ;
22106     char *kwnames[] = {
22107         (char *) "self",(char *) "image", NULL
22108     };
22109
22110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetImage",kwnames,&obj0,&obj1)) goto fail;
22111     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22112     if (SWIG_arg_fail(1)) SWIG_fail;
22113     {
22114         arg2 = (int)(SWIG_As_int(obj1));
22115         if (SWIG_arg_fail(2)) SWIG_fail;
22116     }
22117     {
22118         PyThreadState* __tstate = wxPyBeginAllowThreads();
22119         (arg1)->SetImage(arg2);
22120
22121         wxPyEndAllowThreads(__tstate);
22122         if (PyErr_Occurred()) SWIG_fail;
22123     }
22124     Py_INCREF(Py_None); resultobj = Py_None;
22125     return resultobj;
22126     fail:
22127     return NULL;
22128 }
22129
22130
22131 static PyObject *_wrap_ListItem_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
22132     PyObject *resultobj;
22133     wxListItem *arg1 = (wxListItem *) 0 ;
22134     long arg2 ;
22135     PyObject * obj0 = 0 ;
22136     PyObject * obj1 = 0 ;
22137     char *kwnames[] = {
22138         (char *) "self",(char *) "data", NULL
22139     };
22140
22141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetData",kwnames,&obj0,&obj1)) goto fail;
22142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22143     if (SWIG_arg_fail(1)) SWIG_fail;
22144     {
22145         arg2 = (long)(SWIG_As_long(obj1));
22146         if (SWIG_arg_fail(2)) SWIG_fail;
22147     }
22148     {
22149         PyThreadState* __tstate = wxPyBeginAllowThreads();
22150         (arg1)->SetData(arg2);
22151
22152         wxPyEndAllowThreads(__tstate);
22153         if (PyErr_Occurred()) SWIG_fail;
22154     }
22155     Py_INCREF(Py_None); resultobj = Py_None;
22156     return resultobj;
22157     fail:
22158     return NULL;
22159 }
22160
22161
22162 static PyObject *_wrap_ListItem_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
22163     PyObject *resultobj;
22164     wxListItem *arg1 = (wxListItem *) 0 ;
22165     int arg2 ;
22166     PyObject * obj0 = 0 ;
22167     PyObject * obj1 = 0 ;
22168     char *kwnames[] = {
22169         (char *) "self",(char *) "width", NULL
22170     };
22171
22172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetWidth",kwnames,&obj0,&obj1)) goto fail;
22173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22174     if (SWIG_arg_fail(1)) SWIG_fail;
22175     {
22176         arg2 = (int)(SWIG_As_int(obj1));
22177         if (SWIG_arg_fail(2)) SWIG_fail;
22178     }
22179     {
22180         PyThreadState* __tstate = wxPyBeginAllowThreads();
22181         (arg1)->SetWidth(arg2);
22182
22183         wxPyEndAllowThreads(__tstate);
22184         if (PyErr_Occurred()) SWIG_fail;
22185     }
22186     Py_INCREF(Py_None); resultobj = Py_None;
22187     return resultobj;
22188     fail:
22189     return NULL;
22190 }
22191
22192
22193 static PyObject *_wrap_ListItem_SetAlign(PyObject *, PyObject *args, PyObject *kwargs) {
22194     PyObject *resultobj;
22195     wxListItem *arg1 = (wxListItem *) 0 ;
22196     wxListColumnFormat arg2 ;
22197     PyObject * obj0 = 0 ;
22198     PyObject * obj1 = 0 ;
22199     char *kwnames[] = {
22200         (char *) "self",(char *) "align", NULL
22201     };
22202
22203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetAlign",kwnames,&obj0,&obj1)) goto fail;
22204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22205     if (SWIG_arg_fail(1)) SWIG_fail;
22206     {
22207         arg2 = (wxListColumnFormat)(SWIG_As_int(obj1));
22208         if (SWIG_arg_fail(2)) SWIG_fail;
22209     }
22210     {
22211         PyThreadState* __tstate = wxPyBeginAllowThreads();
22212         (arg1)->SetAlign((wxListColumnFormat )arg2);
22213
22214         wxPyEndAllowThreads(__tstate);
22215         if (PyErr_Occurred()) SWIG_fail;
22216     }
22217     Py_INCREF(Py_None); resultobj = Py_None;
22218     return resultobj;
22219     fail:
22220     return NULL;
22221 }
22222
22223
22224 static PyObject *_wrap_ListItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
22225     PyObject *resultobj;
22226     wxListItem *arg1 = (wxListItem *) 0 ;
22227     wxColour *arg2 = 0 ;
22228     wxColour temp2 ;
22229     PyObject * obj0 = 0 ;
22230     PyObject * obj1 = 0 ;
22231     char *kwnames[] = {
22232         (char *) "self",(char *) "colText", NULL
22233     };
22234
22235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
22236     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22237     if (SWIG_arg_fail(1)) SWIG_fail;
22238     {
22239         arg2 = &temp2;
22240         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22241     }
22242     {
22243         PyThreadState* __tstate = wxPyBeginAllowThreads();
22244         (arg1)->SetTextColour((wxColour const &)*arg2);
22245
22246         wxPyEndAllowThreads(__tstate);
22247         if (PyErr_Occurred()) SWIG_fail;
22248     }
22249     Py_INCREF(Py_None); resultobj = Py_None;
22250     return resultobj;
22251     fail:
22252     return NULL;
22253 }
22254
22255
22256 static PyObject *_wrap_ListItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
22257     PyObject *resultobj;
22258     wxListItem *arg1 = (wxListItem *) 0 ;
22259     wxColour *arg2 = 0 ;
22260     wxColour temp2 ;
22261     PyObject * obj0 = 0 ;
22262     PyObject * obj1 = 0 ;
22263     char *kwnames[] = {
22264         (char *) "self",(char *) "colBack", NULL
22265     };
22266
22267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
22268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22269     if (SWIG_arg_fail(1)) SWIG_fail;
22270     {
22271         arg2 = &temp2;
22272         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22273     }
22274     {
22275         PyThreadState* __tstate = wxPyBeginAllowThreads();
22276         (arg1)->SetBackgroundColour((wxColour const &)*arg2);
22277
22278         wxPyEndAllowThreads(__tstate);
22279         if (PyErr_Occurred()) SWIG_fail;
22280     }
22281     Py_INCREF(Py_None); resultobj = Py_None;
22282     return resultobj;
22283     fail:
22284     return NULL;
22285 }
22286
22287
22288 static PyObject *_wrap_ListItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
22289     PyObject *resultobj;
22290     wxListItem *arg1 = (wxListItem *) 0 ;
22291     wxFont *arg2 = 0 ;
22292     PyObject * obj0 = 0 ;
22293     PyObject * obj1 = 0 ;
22294     char *kwnames[] = {
22295         (char *) "self",(char *) "font", NULL
22296     };
22297
22298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetFont",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
22303         if (SWIG_arg_fail(2)) SWIG_fail;
22304         if (arg2 == NULL) {
22305             SWIG_null_ref("wxFont");
22306         }
22307         if (SWIG_arg_fail(2)) SWIG_fail;
22308     }
22309     {
22310         PyThreadState* __tstate = wxPyBeginAllowThreads();
22311         (arg1)->SetFont((wxFont const &)*arg2);
22312
22313         wxPyEndAllowThreads(__tstate);
22314         if (PyErr_Occurred()) SWIG_fail;
22315     }
22316     Py_INCREF(Py_None); resultobj = Py_None;
22317     return resultobj;
22318     fail:
22319     return NULL;
22320 }
22321
22322
22323 static PyObject *_wrap_ListItem_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
22324     PyObject *resultobj;
22325     wxListItem *arg1 = (wxListItem *) 0 ;
22326     long result;
22327     PyObject * obj0 = 0 ;
22328     char *kwnames[] = {
22329         (char *) "self", NULL
22330     };
22331
22332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetMask",kwnames,&obj0)) goto fail;
22333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22334     if (SWIG_arg_fail(1)) SWIG_fail;
22335     {
22336         PyThreadState* __tstate = wxPyBeginAllowThreads();
22337         result = (long)(arg1)->GetMask();
22338
22339         wxPyEndAllowThreads(__tstate);
22340         if (PyErr_Occurred()) SWIG_fail;
22341     }
22342     {
22343         resultobj = SWIG_From_long((long)(result));
22344     }
22345     return resultobj;
22346     fail:
22347     return NULL;
22348 }
22349
22350
22351 static PyObject *_wrap_ListItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
22352     PyObject *resultobj;
22353     wxListItem *arg1 = (wxListItem *) 0 ;
22354     long result;
22355     PyObject * obj0 = 0 ;
22356     char *kwnames[] = {
22357         (char *) "self", NULL
22358     };
22359
22360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetId",kwnames,&obj0)) goto fail;
22361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22362     if (SWIG_arg_fail(1)) SWIG_fail;
22363     {
22364         PyThreadState* __tstate = wxPyBeginAllowThreads();
22365         result = (long)(arg1)->GetId();
22366
22367         wxPyEndAllowThreads(__tstate);
22368         if (PyErr_Occurred()) SWIG_fail;
22369     }
22370     {
22371         resultobj = SWIG_From_long((long)(result));
22372     }
22373     return resultobj;
22374     fail:
22375     return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_ListItem_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
22380     PyObject *resultobj;
22381     wxListItem *arg1 = (wxListItem *) 0 ;
22382     int result;
22383     PyObject * obj0 = 0 ;
22384     char *kwnames[] = {
22385         (char *) "self", NULL
22386     };
22387
22388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetColumn",kwnames,&obj0)) goto fail;
22389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22390     if (SWIG_arg_fail(1)) SWIG_fail;
22391     {
22392         PyThreadState* __tstate = wxPyBeginAllowThreads();
22393         result = (int)(arg1)->GetColumn();
22394
22395         wxPyEndAllowThreads(__tstate);
22396         if (PyErr_Occurred()) SWIG_fail;
22397     }
22398     {
22399         resultobj = SWIG_From_int((int)(result));
22400     }
22401     return resultobj;
22402     fail:
22403     return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_ListItem_GetState(PyObject *, PyObject *args, PyObject *kwargs) {
22408     PyObject *resultobj;
22409     wxListItem *arg1 = (wxListItem *) 0 ;
22410     long result;
22411     PyObject * obj0 = 0 ;
22412     char *kwnames[] = {
22413         (char *) "self", NULL
22414     };
22415
22416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetState",kwnames,&obj0)) goto fail;
22417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22418     if (SWIG_arg_fail(1)) SWIG_fail;
22419     {
22420         PyThreadState* __tstate = wxPyBeginAllowThreads();
22421         result = (long)(arg1)->GetState();
22422
22423         wxPyEndAllowThreads(__tstate);
22424         if (PyErr_Occurred()) SWIG_fail;
22425     }
22426     {
22427         resultobj = SWIG_From_long((long)(result));
22428     }
22429     return resultobj;
22430     fail:
22431     return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_ListItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
22436     PyObject *resultobj;
22437     wxListItem *arg1 = (wxListItem *) 0 ;
22438     wxString *result;
22439     PyObject * obj0 = 0 ;
22440     char *kwnames[] = {
22441         (char *) "self", NULL
22442     };
22443
22444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetText",kwnames,&obj0)) goto fail;
22445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22446     if (SWIG_arg_fail(1)) SWIG_fail;
22447     {
22448         PyThreadState* __tstate = wxPyBeginAllowThreads();
22449         {
22450             wxString const &_result_ref = (arg1)->GetText();
22451             result = (wxString *) &_result_ref;
22452         }
22453
22454         wxPyEndAllowThreads(__tstate);
22455         if (PyErr_Occurred()) SWIG_fail;
22456     }
22457     {
22458 #if wxUSE_UNICODE
22459         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22460 #else
22461         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22462 #endif
22463     }
22464     return resultobj;
22465     fail:
22466     return NULL;
22467 }
22468
22469
22470 static PyObject *_wrap_ListItem_GetImage(PyObject *, PyObject *args, PyObject *kwargs) {
22471     PyObject *resultobj;
22472     wxListItem *arg1 = (wxListItem *) 0 ;
22473     int result;
22474     PyObject * obj0 = 0 ;
22475     char *kwnames[] = {
22476         (char *) "self", NULL
22477     };
22478
22479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetImage",kwnames,&obj0)) goto fail;
22480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22481     if (SWIG_arg_fail(1)) SWIG_fail;
22482     {
22483         PyThreadState* __tstate = wxPyBeginAllowThreads();
22484         result = (int)(arg1)->GetImage();
22485
22486         wxPyEndAllowThreads(__tstate);
22487         if (PyErr_Occurred()) SWIG_fail;
22488     }
22489     {
22490         resultobj = SWIG_From_int((int)(result));
22491     }
22492     return resultobj;
22493     fail:
22494     return NULL;
22495 }
22496
22497
22498 static PyObject *_wrap_ListItem_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
22499     PyObject *resultobj;
22500     wxListItem *arg1 = (wxListItem *) 0 ;
22501     long result;
22502     PyObject * obj0 = 0 ;
22503     char *kwnames[] = {
22504         (char *) "self", NULL
22505     };
22506
22507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetData",kwnames,&obj0)) goto fail;
22508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22509     if (SWIG_arg_fail(1)) SWIG_fail;
22510     {
22511         PyThreadState* __tstate = wxPyBeginAllowThreads();
22512         result = (long)(arg1)->GetData();
22513
22514         wxPyEndAllowThreads(__tstate);
22515         if (PyErr_Occurred()) SWIG_fail;
22516     }
22517     {
22518         resultobj = SWIG_From_long((long)(result));
22519     }
22520     return resultobj;
22521     fail:
22522     return NULL;
22523 }
22524
22525
22526 static PyObject *_wrap_ListItem_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
22527     PyObject *resultobj;
22528     wxListItem *arg1 = (wxListItem *) 0 ;
22529     int result;
22530     PyObject * obj0 = 0 ;
22531     char *kwnames[] = {
22532         (char *) "self", NULL
22533     };
22534
22535     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetWidth",kwnames,&obj0)) goto fail;
22536     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22537     if (SWIG_arg_fail(1)) SWIG_fail;
22538     {
22539         PyThreadState* __tstate = wxPyBeginAllowThreads();
22540         result = (int)(arg1)->GetWidth();
22541
22542         wxPyEndAllowThreads(__tstate);
22543         if (PyErr_Occurred()) SWIG_fail;
22544     }
22545     {
22546         resultobj = SWIG_From_int((int)(result));
22547     }
22548     return resultobj;
22549     fail:
22550     return NULL;
22551 }
22552
22553
22554 static PyObject *_wrap_ListItem_GetAlign(PyObject *, PyObject *args, PyObject *kwargs) {
22555     PyObject *resultobj;
22556     wxListItem *arg1 = (wxListItem *) 0 ;
22557     wxListColumnFormat result;
22558     PyObject * obj0 = 0 ;
22559     char *kwnames[] = {
22560         (char *) "self", NULL
22561     };
22562
22563     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetAlign",kwnames,&obj0)) goto fail;
22564     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22565     if (SWIG_arg_fail(1)) SWIG_fail;
22566     {
22567         PyThreadState* __tstate = wxPyBeginAllowThreads();
22568         result = (wxListColumnFormat)(arg1)->GetAlign();
22569
22570         wxPyEndAllowThreads(__tstate);
22571         if (PyErr_Occurred()) SWIG_fail;
22572     }
22573     resultobj = SWIG_From_int((result));
22574     return resultobj;
22575     fail:
22576     return NULL;
22577 }
22578
22579
22580 static PyObject *_wrap_ListItem_GetAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
22581     PyObject *resultobj;
22582     wxListItem *arg1 = (wxListItem *) 0 ;
22583     wxListItemAttr *result;
22584     PyObject * obj0 = 0 ;
22585     char *kwnames[] = {
22586         (char *) "self", NULL
22587     };
22588
22589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetAttributes",kwnames,&obj0)) goto fail;
22590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22591     if (SWIG_arg_fail(1)) SWIG_fail;
22592     {
22593         PyThreadState* __tstate = wxPyBeginAllowThreads();
22594         result = (wxListItemAttr *)(arg1)->GetAttributes();
22595
22596         wxPyEndAllowThreads(__tstate);
22597         if (PyErr_Occurred()) SWIG_fail;
22598     }
22599     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItemAttr, 0);
22600     return resultobj;
22601     fail:
22602     return NULL;
22603 }
22604
22605
22606 static PyObject *_wrap_ListItem_HasAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
22607     PyObject *resultobj;
22608     wxListItem *arg1 = (wxListItem *) 0 ;
22609     bool result;
22610     PyObject * obj0 = 0 ;
22611     char *kwnames[] = {
22612         (char *) "self", NULL
22613     };
22614
22615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_HasAttributes",kwnames,&obj0)) goto fail;
22616     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22617     if (SWIG_arg_fail(1)) SWIG_fail;
22618     {
22619         PyThreadState* __tstate = wxPyBeginAllowThreads();
22620         result = (bool)(arg1)->HasAttributes();
22621
22622         wxPyEndAllowThreads(__tstate);
22623         if (PyErr_Occurred()) SWIG_fail;
22624     }
22625     {
22626         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22627     }
22628     return resultobj;
22629     fail:
22630     return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_ListItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
22635     PyObject *resultobj;
22636     wxListItem *arg1 = (wxListItem *) 0 ;
22637     wxColour result;
22638     PyObject * obj0 = 0 ;
22639     char *kwnames[] = {
22640         (char *) "self", NULL
22641     };
22642
22643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetTextColour",kwnames,&obj0)) goto fail;
22644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22645     if (SWIG_arg_fail(1)) SWIG_fail;
22646     {
22647         PyThreadState* __tstate = wxPyBeginAllowThreads();
22648         result = ((wxListItem const *)arg1)->GetTextColour();
22649
22650         wxPyEndAllowThreads(__tstate);
22651         if (PyErr_Occurred()) SWIG_fail;
22652     }
22653     {
22654         wxColour * resultptr;
22655         resultptr = new wxColour((wxColour &)(result));
22656         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
22657     }
22658     return resultobj;
22659     fail:
22660     return NULL;
22661 }
22662
22663
22664 static PyObject *_wrap_ListItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
22665     PyObject *resultobj;
22666     wxListItem *arg1 = (wxListItem *) 0 ;
22667     wxColour result;
22668     PyObject * obj0 = 0 ;
22669     char *kwnames[] = {
22670         (char *) "self", NULL
22671     };
22672
22673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
22674     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22675     if (SWIG_arg_fail(1)) SWIG_fail;
22676     {
22677         PyThreadState* __tstate = wxPyBeginAllowThreads();
22678         result = ((wxListItem const *)arg1)->GetBackgroundColour();
22679
22680         wxPyEndAllowThreads(__tstate);
22681         if (PyErr_Occurred()) SWIG_fail;
22682     }
22683     {
22684         wxColour * resultptr;
22685         resultptr = new wxColour((wxColour &)(result));
22686         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
22687     }
22688     return resultobj;
22689     fail:
22690     return NULL;
22691 }
22692
22693
22694 static PyObject *_wrap_ListItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
22695     PyObject *resultobj;
22696     wxListItem *arg1 = (wxListItem *) 0 ;
22697     wxFont result;
22698     PyObject * obj0 = 0 ;
22699     char *kwnames[] = {
22700         (char *) "self", NULL
22701     };
22702
22703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_GetFont",kwnames,&obj0)) goto fail;
22704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22705     if (SWIG_arg_fail(1)) SWIG_fail;
22706     {
22707         PyThreadState* __tstate = wxPyBeginAllowThreads();
22708         result = ((wxListItem const *)arg1)->GetFont();
22709
22710         wxPyEndAllowThreads(__tstate);
22711         if (PyErr_Occurred()) SWIG_fail;
22712     }
22713     {
22714         wxFont * resultptr;
22715         resultptr = new wxFont((wxFont &)(result));
22716         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
22717     }
22718     return resultobj;
22719     fail:
22720     return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_ListItem_m_mask_set(PyObject *, PyObject *args, PyObject *kwargs) {
22725     PyObject *resultobj;
22726     wxListItem *arg1 = (wxListItem *) 0 ;
22727     long arg2 ;
22728     PyObject * obj0 = 0 ;
22729     PyObject * obj1 = 0 ;
22730     char *kwnames[] = {
22731         (char *) "self",(char *) "m_mask", NULL
22732     };
22733
22734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_mask_set",kwnames,&obj0,&obj1)) goto fail;
22735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22736     if (SWIG_arg_fail(1)) SWIG_fail;
22737     {
22738         arg2 = (long)(SWIG_As_long(obj1));
22739         if (SWIG_arg_fail(2)) SWIG_fail;
22740     }
22741     if (arg1) (arg1)->m_mask = arg2;
22742
22743     Py_INCREF(Py_None); resultobj = Py_None;
22744     return resultobj;
22745     fail:
22746     return NULL;
22747 }
22748
22749
22750 static PyObject *_wrap_ListItem_m_mask_get(PyObject *, PyObject *args, PyObject *kwargs) {
22751     PyObject *resultobj;
22752     wxListItem *arg1 = (wxListItem *) 0 ;
22753     long result;
22754     PyObject * obj0 = 0 ;
22755     char *kwnames[] = {
22756         (char *) "self", NULL
22757     };
22758
22759     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_mask_get",kwnames,&obj0)) goto fail;
22760     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22761     if (SWIG_arg_fail(1)) SWIG_fail;
22762     result = (long) ((arg1)->m_mask);
22763
22764     {
22765         resultobj = SWIG_From_long((long)(result));
22766     }
22767     return resultobj;
22768     fail:
22769     return NULL;
22770 }
22771
22772
22773 static PyObject *_wrap_ListItem_m_itemId_set(PyObject *, PyObject *args, PyObject *kwargs) {
22774     PyObject *resultobj;
22775     wxListItem *arg1 = (wxListItem *) 0 ;
22776     long arg2 ;
22777     PyObject * obj0 = 0 ;
22778     PyObject * obj1 = 0 ;
22779     char *kwnames[] = {
22780         (char *) "self",(char *) "m_itemId", NULL
22781     };
22782
22783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_itemId_set",kwnames,&obj0,&obj1)) goto fail;
22784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22785     if (SWIG_arg_fail(1)) SWIG_fail;
22786     {
22787         arg2 = (long)(SWIG_As_long(obj1));
22788         if (SWIG_arg_fail(2)) SWIG_fail;
22789     }
22790     if (arg1) (arg1)->m_itemId = arg2;
22791
22792     Py_INCREF(Py_None); resultobj = Py_None;
22793     return resultobj;
22794     fail:
22795     return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_ListItem_m_itemId_get(PyObject *, PyObject *args, PyObject *kwargs) {
22800     PyObject *resultobj;
22801     wxListItem *arg1 = (wxListItem *) 0 ;
22802     long result;
22803     PyObject * obj0 = 0 ;
22804     char *kwnames[] = {
22805         (char *) "self", NULL
22806     };
22807
22808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_itemId_get",kwnames,&obj0)) goto fail;
22809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22810     if (SWIG_arg_fail(1)) SWIG_fail;
22811     result = (long) ((arg1)->m_itemId);
22812
22813     {
22814         resultobj = SWIG_From_long((long)(result));
22815     }
22816     return resultobj;
22817     fail:
22818     return NULL;
22819 }
22820
22821
22822 static PyObject *_wrap_ListItem_m_col_set(PyObject *, PyObject *args, PyObject *kwargs) {
22823     PyObject *resultobj;
22824     wxListItem *arg1 = (wxListItem *) 0 ;
22825     int arg2 ;
22826     PyObject * obj0 = 0 ;
22827     PyObject * obj1 = 0 ;
22828     char *kwnames[] = {
22829         (char *) "self",(char *) "m_col", NULL
22830     };
22831
22832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_col_set",kwnames,&obj0,&obj1)) goto fail;
22833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22834     if (SWIG_arg_fail(1)) SWIG_fail;
22835     {
22836         arg2 = (int)(SWIG_As_int(obj1));
22837         if (SWIG_arg_fail(2)) SWIG_fail;
22838     }
22839     if (arg1) (arg1)->m_col = arg2;
22840
22841     Py_INCREF(Py_None); resultobj = Py_None;
22842     return resultobj;
22843     fail:
22844     return NULL;
22845 }
22846
22847
22848 static PyObject *_wrap_ListItem_m_col_get(PyObject *, PyObject *args, PyObject *kwargs) {
22849     PyObject *resultobj;
22850     wxListItem *arg1 = (wxListItem *) 0 ;
22851     int result;
22852     PyObject * obj0 = 0 ;
22853     char *kwnames[] = {
22854         (char *) "self", NULL
22855     };
22856
22857     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_col_get",kwnames,&obj0)) goto fail;
22858     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22859     if (SWIG_arg_fail(1)) SWIG_fail;
22860     result = (int) ((arg1)->m_col);
22861
22862     {
22863         resultobj = SWIG_From_int((int)(result));
22864     }
22865     return resultobj;
22866     fail:
22867     return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_ListItem_m_state_set(PyObject *, PyObject *args, PyObject *kwargs) {
22872     PyObject *resultobj;
22873     wxListItem *arg1 = (wxListItem *) 0 ;
22874     long arg2 ;
22875     PyObject * obj0 = 0 ;
22876     PyObject * obj1 = 0 ;
22877     char *kwnames[] = {
22878         (char *) "self",(char *) "m_state", NULL
22879     };
22880
22881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_state_set",kwnames,&obj0,&obj1)) goto fail;
22882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22883     if (SWIG_arg_fail(1)) SWIG_fail;
22884     {
22885         arg2 = (long)(SWIG_As_long(obj1));
22886         if (SWIG_arg_fail(2)) SWIG_fail;
22887     }
22888     if (arg1) (arg1)->m_state = arg2;
22889
22890     Py_INCREF(Py_None); resultobj = Py_None;
22891     return resultobj;
22892     fail:
22893     return NULL;
22894 }
22895
22896
22897 static PyObject *_wrap_ListItem_m_state_get(PyObject *, PyObject *args, PyObject *kwargs) {
22898     PyObject *resultobj;
22899     wxListItem *arg1 = (wxListItem *) 0 ;
22900     long result;
22901     PyObject * obj0 = 0 ;
22902     char *kwnames[] = {
22903         (char *) "self", NULL
22904     };
22905
22906     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_state_get",kwnames,&obj0)) goto fail;
22907     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22908     if (SWIG_arg_fail(1)) SWIG_fail;
22909     result = (long) ((arg1)->m_state);
22910
22911     {
22912         resultobj = SWIG_From_long((long)(result));
22913     }
22914     return resultobj;
22915     fail:
22916     return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_ListItem_m_stateMask_set(PyObject *, PyObject *args, PyObject *kwargs) {
22921     PyObject *resultobj;
22922     wxListItem *arg1 = (wxListItem *) 0 ;
22923     long arg2 ;
22924     PyObject * obj0 = 0 ;
22925     PyObject * obj1 = 0 ;
22926     char *kwnames[] = {
22927         (char *) "self",(char *) "m_stateMask", NULL
22928     };
22929
22930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_stateMask_set",kwnames,&obj0,&obj1)) goto fail;
22931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22932     if (SWIG_arg_fail(1)) SWIG_fail;
22933     {
22934         arg2 = (long)(SWIG_As_long(obj1));
22935         if (SWIG_arg_fail(2)) SWIG_fail;
22936     }
22937     if (arg1) (arg1)->m_stateMask = arg2;
22938
22939     Py_INCREF(Py_None); resultobj = Py_None;
22940     return resultobj;
22941     fail:
22942     return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_ListItem_m_stateMask_get(PyObject *, PyObject *args, PyObject *kwargs) {
22947     PyObject *resultobj;
22948     wxListItem *arg1 = (wxListItem *) 0 ;
22949     long result;
22950     PyObject * obj0 = 0 ;
22951     char *kwnames[] = {
22952         (char *) "self", NULL
22953     };
22954
22955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_stateMask_get",kwnames,&obj0)) goto fail;
22956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
22957     if (SWIG_arg_fail(1)) SWIG_fail;
22958     result = (long) ((arg1)->m_stateMask);
22959
22960     {
22961         resultobj = SWIG_From_long((long)(result));
22962     }
22963     return resultobj;
22964     fail:
22965     return NULL;
22966 }
22967
22968
22969 static PyObject *_wrap_ListItem_m_text_set(PyObject *, PyObject *args, PyObject *kwargs) {
22970     PyObject *resultobj;
22971     wxListItem *arg1 = (wxListItem *) 0 ;
22972     wxString *arg2 = (wxString *) 0 ;
22973     bool temp2 = false ;
22974     PyObject * obj0 = 0 ;
22975     PyObject * obj1 = 0 ;
22976     char *kwnames[] = {
22977         (char *) "self",(char *) "m_text", NULL
22978     };
22979
22980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_text_set",kwnames,&obj0,&obj1)) 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     {
22984         arg2 = wxString_in_helper(obj1);
22985         if (arg2 == NULL) SWIG_fail;
22986         temp2 = true;
22987     }
22988     if (arg1) (arg1)->m_text = *arg2;
22989
22990     Py_INCREF(Py_None); resultobj = Py_None;
22991     {
22992         if (temp2)
22993         delete arg2;
22994     }
22995     return resultobj;
22996     fail:
22997     {
22998         if (temp2)
22999         delete arg2;
23000     }
23001     return NULL;
23002 }
23003
23004
23005 static PyObject *_wrap_ListItem_m_text_get(PyObject *, PyObject *args, PyObject *kwargs) {
23006     PyObject *resultobj;
23007     wxListItem *arg1 = (wxListItem *) 0 ;
23008     wxString *result;
23009     PyObject * obj0 = 0 ;
23010     char *kwnames[] = {
23011         (char *) "self", NULL
23012     };
23013
23014     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_text_get",kwnames,&obj0)) goto fail;
23015     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23016     if (SWIG_arg_fail(1)) SWIG_fail;
23017     result = (wxString *)& ((arg1)->m_text);
23018
23019     {
23020 #if wxUSE_UNICODE
23021         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23022 #else
23023         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23024 #endif
23025     }
23026     return resultobj;
23027     fail:
23028     return NULL;
23029 }
23030
23031
23032 static PyObject *_wrap_ListItem_m_image_set(PyObject *, PyObject *args, PyObject *kwargs) {
23033     PyObject *resultobj;
23034     wxListItem *arg1 = (wxListItem *) 0 ;
23035     int arg2 ;
23036     PyObject * obj0 = 0 ;
23037     PyObject * obj1 = 0 ;
23038     char *kwnames[] = {
23039         (char *) "self",(char *) "m_image", NULL
23040     };
23041
23042     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_image_set",kwnames,&obj0,&obj1)) goto fail;
23043     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23044     if (SWIG_arg_fail(1)) SWIG_fail;
23045     {
23046         arg2 = (int)(SWIG_As_int(obj1));
23047         if (SWIG_arg_fail(2)) SWIG_fail;
23048     }
23049     if (arg1) (arg1)->m_image = arg2;
23050
23051     Py_INCREF(Py_None); resultobj = Py_None;
23052     return resultobj;
23053     fail:
23054     return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_ListItem_m_image_get(PyObject *, PyObject *args, PyObject *kwargs) {
23059     PyObject *resultobj;
23060     wxListItem *arg1 = (wxListItem *) 0 ;
23061     int result;
23062     PyObject * obj0 = 0 ;
23063     char *kwnames[] = {
23064         (char *) "self", NULL
23065     };
23066
23067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_image_get",kwnames,&obj0)) goto fail;
23068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23069     if (SWIG_arg_fail(1)) SWIG_fail;
23070     result = (int) ((arg1)->m_image);
23071
23072     {
23073         resultobj = SWIG_From_int((int)(result));
23074     }
23075     return resultobj;
23076     fail:
23077     return NULL;
23078 }
23079
23080
23081 static PyObject *_wrap_ListItem_m_data_set(PyObject *, PyObject *args, PyObject *kwargs) {
23082     PyObject *resultobj;
23083     wxListItem *arg1 = (wxListItem *) 0 ;
23084     long arg2 ;
23085     PyObject * obj0 = 0 ;
23086     PyObject * obj1 = 0 ;
23087     char *kwnames[] = {
23088         (char *) "self",(char *) "m_data", NULL
23089     };
23090
23091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_data_set",kwnames,&obj0,&obj1)) goto fail;
23092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23093     if (SWIG_arg_fail(1)) SWIG_fail;
23094     {
23095         arg2 = (long)(SWIG_As_long(obj1));
23096         if (SWIG_arg_fail(2)) SWIG_fail;
23097     }
23098     if (arg1) (arg1)->m_data = arg2;
23099
23100     Py_INCREF(Py_None); resultobj = Py_None;
23101     return resultobj;
23102     fail:
23103     return NULL;
23104 }
23105
23106
23107 static PyObject *_wrap_ListItem_m_data_get(PyObject *, PyObject *args, PyObject *kwargs) {
23108     PyObject *resultobj;
23109     wxListItem *arg1 = (wxListItem *) 0 ;
23110     long result;
23111     PyObject * obj0 = 0 ;
23112     char *kwnames[] = {
23113         (char *) "self", NULL
23114     };
23115
23116     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_data_get",kwnames,&obj0)) goto fail;
23117     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23118     if (SWIG_arg_fail(1)) SWIG_fail;
23119     result = (long) ((arg1)->m_data);
23120
23121     {
23122         resultobj = SWIG_From_long((long)(result));
23123     }
23124     return resultobj;
23125     fail:
23126     return NULL;
23127 }
23128
23129
23130 static PyObject *_wrap_ListItem_m_format_set(PyObject *, PyObject *args, PyObject *kwargs) {
23131     PyObject *resultobj;
23132     wxListItem *arg1 = (wxListItem *) 0 ;
23133     int arg2 ;
23134     PyObject * obj0 = 0 ;
23135     PyObject * obj1 = 0 ;
23136     char *kwnames[] = {
23137         (char *) "self",(char *) "m_format", NULL
23138     };
23139
23140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_format_set",kwnames,&obj0,&obj1)) goto fail;
23141     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23142     if (SWIG_arg_fail(1)) SWIG_fail;
23143     {
23144         arg2 = (int)(SWIG_As_int(obj1));
23145         if (SWIG_arg_fail(2)) SWIG_fail;
23146     }
23147     if (arg1) (arg1)->m_format = arg2;
23148
23149     Py_INCREF(Py_None); resultobj = Py_None;
23150     return resultobj;
23151     fail:
23152     return NULL;
23153 }
23154
23155
23156 static PyObject *_wrap_ListItem_m_format_get(PyObject *, PyObject *args, PyObject *kwargs) {
23157     PyObject *resultobj;
23158     wxListItem *arg1 = (wxListItem *) 0 ;
23159     int result;
23160     PyObject * obj0 = 0 ;
23161     char *kwnames[] = {
23162         (char *) "self", NULL
23163     };
23164
23165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_format_get",kwnames,&obj0)) goto fail;
23166     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23167     if (SWIG_arg_fail(1)) SWIG_fail;
23168     result = (int) ((arg1)->m_format);
23169
23170     {
23171         resultobj = SWIG_From_int((int)(result));
23172     }
23173     return resultobj;
23174     fail:
23175     return NULL;
23176 }
23177
23178
23179 static PyObject *_wrap_ListItem_m_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
23180     PyObject *resultobj;
23181     wxListItem *arg1 = (wxListItem *) 0 ;
23182     int arg2 ;
23183     PyObject * obj0 = 0 ;
23184     PyObject * obj1 = 0 ;
23185     char *kwnames[] = {
23186         (char *) "self",(char *) "m_width", NULL
23187     };
23188
23189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_width_set",kwnames,&obj0,&obj1)) goto fail;
23190     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23191     if (SWIG_arg_fail(1)) SWIG_fail;
23192     {
23193         arg2 = (int)(SWIG_As_int(obj1));
23194         if (SWIG_arg_fail(2)) SWIG_fail;
23195     }
23196     if (arg1) (arg1)->m_width = arg2;
23197
23198     Py_INCREF(Py_None); resultobj = Py_None;
23199     return resultobj;
23200     fail:
23201     return NULL;
23202 }
23203
23204
23205 static PyObject *_wrap_ListItem_m_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
23206     PyObject *resultobj;
23207     wxListItem *arg1 = (wxListItem *) 0 ;
23208     int result;
23209     PyObject * obj0 = 0 ;
23210     char *kwnames[] = {
23211         (char *) "self", NULL
23212     };
23213
23214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_width_get",kwnames,&obj0)) goto fail;
23215     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
23216     if (SWIG_arg_fail(1)) SWIG_fail;
23217     result = (int) ((arg1)->m_width);
23218
23219     {
23220         resultobj = SWIG_From_int((int)(result));
23221     }
23222     return resultobj;
23223     fail:
23224     return NULL;
23225 }
23226
23227
23228 static PyObject * ListItem_swigregister(PyObject *, PyObject *args) {
23229     PyObject *obj;
23230     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23231     SWIG_TypeClientData(SWIGTYPE_p_wxListItem, obj);
23232     Py_INCREF(obj);
23233     return Py_BuildValue((char *)"");
23234 }
23235 static PyObject *_wrap_new_ListEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23236     PyObject *resultobj;
23237     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23238     int arg2 = (int) 0 ;
23239     wxListEvent *result;
23240     PyObject * obj0 = 0 ;
23241     PyObject * obj1 = 0 ;
23242     char *kwnames[] = {
23243         (char *) "commandType",(char *) "id", NULL
23244     };
23245
23246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ListEvent",kwnames,&obj0,&obj1)) goto fail;
23247     if (obj0) {
23248         {
23249             arg1 = (wxEventType)(SWIG_As_int(obj0));
23250             if (SWIG_arg_fail(1)) SWIG_fail;
23251         }
23252     }
23253     if (obj1) {
23254         {
23255             arg2 = (int)(SWIG_As_int(obj1));
23256             if (SWIG_arg_fail(2)) SWIG_fail;
23257         }
23258     }
23259     {
23260         PyThreadState* __tstate = wxPyBeginAllowThreads();
23261         result = (wxListEvent *)new wxListEvent(arg1,arg2);
23262
23263         wxPyEndAllowThreads(__tstate);
23264         if (PyErr_Occurred()) SWIG_fail;
23265     }
23266     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListEvent, 1);
23267     return resultobj;
23268     fail:
23269     return NULL;
23270 }
23271
23272
23273 static PyObject *_wrap_ListEvent_m_code_set(PyObject *, PyObject *args, PyObject *kwargs) {
23274     PyObject *resultobj;
23275     wxListEvent *arg1 = (wxListEvent *) 0 ;
23276     int arg2 ;
23277     PyObject * obj0 = 0 ;
23278     PyObject * obj1 = 0 ;
23279     char *kwnames[] = {
23280         (char *) "self",(char *) "m_code", NULL
23281     };
23282
23283     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_code_set",kwnames,&obj0,&obj1)) goto fail;
23284     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23285     if (SWIG_arg_fail(1)) SWIG_fail;
23286     {
23287         arg2 = (int)(SWIG_As_int(obj1));
23288         if (SWIG_arg_fail(2)) SWIG_fail;
23289     }
23290     if (arg1) (arg1)->m_code = arg2;
23291
23292     Py_INCREF(Py_None); resultobj = Py_None;
23293     return resultobj;
23294     fail:
23295     return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_ListEvent_m_code_get(PyObject *, PyObject *args, PyObject *kwargs) {
23300     PyObject *resultobj;
23301     wxListEvent *arg1 = (wxListEvent *) 0 ;
23302     int result;
23303     PyObject * obj0 = 0 ;
23304     char *kwnames[] = {
23305         (char *) "self", NULL
23306     };
23307
23308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_code_get",kwnames,&obj0)) goto fail;
23309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23310     if (SWIG_arg_fail(1)) SWIG_fail;
23311     result = (int) ((arg1)->m_code);
23312
23313     {
23314         resultobj = SWIG_From_int((int)(result));
23315     }
23316     return resultobj;
23317     fail:
23318     return NULL;
23319 }
23320
23321
23322 static PyObject *_wrap_ListEvent_m_oldItemIndex_set(PyObject *, PyObject *args, PyObject *kwargs) {
23323     PyObject *resultobj;
23324     wxListEvent *arg1 = (wxListEvent *) 0 ;
23325     long arg2 ;
23326     PyObject * obj0 = 0 ;
23327     PyObject * obj1 = 0 ;
23328     char *kwnames[] = {
23329         (char *) "self",(char *) "m_oldItemIndex", NULL
23330     };
23331
23332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_oldItemIndex_set",kwnames,&obj0,&obj1)) goto fail;
23333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23334     if (SWIG_arg_fail(1)) SWIG_fail;
23335     {
23336         arg2 = (long)(SWIG_As_long(obj1));
23337         if (SWIG_arg_fail(2)) SWIG_fail;
23338     }
23339     if (arg1) (arg1)->m_oldItemIndex = arg2;
23340
23341     Py_INCREF(Py_None); resultobj = Py_None;
23342     return resultobj;
23343     fail:
23344     return NULL;
23345 }
23346
23347
23348 static PyObject *_wrap_ListEvent_m_oldItemIndex_get(PyObject *, PyObject *args, PyObject *kwargs) {
23349     PyObject *resultobj;
23350     wxListEvent *arg1 = (wxListEvent *) 0 ;
23351     long result;
23352     PyObject * obj0 = 0 ;
23353     char *kwnames[] = {
23354         (char *) "self", NULL
23355     };
23356
23357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_oldItemIndex_get",kwnames,&obj0)) goto fail;
23358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23359     if (SWIG_arg_fail(1)) SWIG_fail;
23360     result = (long) ((arg1)->m_oldItemIndex);
23361
23362     {
23363         resultobj = SWIG_From_long((long)(result));
23364     }
23365     return resultobj;
23366     fail:
23367     return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_ListEvent_m_itemIndex_set(PyObject *, PyObject *args, PyObject *kwargs) {
23372     PyObject *resultobj;
23373     wxListEvent *arg1 = (wxListEvent *) 0 ;
23374     long arg2 ;
23375     PyObject * obj0 = 0 ;
23376     PyObject * obj1 = 0 ;
23377     char *kwnames[] = {
23378         (char *) "self",(char *) "m_itemIndex", NULL
23379     };
23380
23381     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_itemIndex_set",kwnames,&obj0,&obj1)) goto fail;
23382     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23383     if (SWIG_arg_fail(1)) SWIG_fail;
23384     {
23385         arg2 = (long)(SWIG_As_long(obj1));
23386         if (SWIG_arg_fail(2)) SWIG_fail;
23387     }
23388     if (arg1) (arg1)->m_itemIndex = arg2;
23389
23390     Py_INCREF(Py_None); resultobj = Py_None;
23391     return resultobj;
23392     fail:
23393     return NULL;
23394 }
23395
23396
23397 static PyObject *_wrap_ListEvent_m_itemIndex_get(PyObject *, PyObject *args, PyObject *kwargs) {
23398     PyObject *resultobj;
23399     wxListEvent *arg1 = (wxListEvent *) 0 ;
23400     long result;
23401     PyObject * obj0 = 0 ;
23402     char *kwnames[] = {
23403         (char *) "self", NULL
23404     };
23405
23406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_itemIndex_get",kwnames,&obj0)) goto fail;
23407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23408     if (SWIG_arg_fail(1)) SWIG_fail;
23409     result = (long) ((arg1)->m_itemIndex);
23410
23411     {
23412         resultobj = SWIG_From_long((long)(result));
23413     }
23414     return resultobj;
23415     fail:
23416     return NULL;
23417 }
23418
23419
23420 static PyObject *_wrap_ListEvent_m_col_set(PyObject *, PyObject *args, PyObject *kwargs) {
23421     PyObject *resultobj;
23422     wxListEvent *arg1 = (wxListEvent *) 0 ;
23423     int arg2 ;
23424     PyObject * obj0 = 0 ;
23425     PyObject * obj1 = 0 ;
23426     char *kwnames[] = {
23427         (char *) "self",(char *) "m_col", NULL
23428     };
23429
23430     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_col_set",kwnames,&obj0,&obj1)) goto fail;
23431     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23432     if (SWIG_arg_fail(1)) SWIG_fail;
23433     {
23434         arg2 = (int)(SWIG_As_int(obj1));
23435         if (SWIG_arg_fail(2)) SWIG_fail;
23436     }
23437     if (arg1) (arg1)->m_col = arg2;
23438
23439     Py_INCREF(Py_None); resultobj = Py_None;
23440     return resultobj;
23441     fail:
23442     return NULL;
23443 }
23444
23445
23446 static PyObject *_wrap_ListEvent_m_col_get(PyObject *, PyObject *args, PyObject *kwargs) {
23447     PyObject *resultobj;
23448     wxListEvent *arg1 = (wxListEvent *) 0 ;
23449     int result;
23450     PyObject * obj0 = 0 ;
23451     char *kwnames[] = {
23452         (char *) "self", NULL
23453     };
23454
23455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_col_get",kwnames,&obj0)) goto fail;
23456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23457     if (SWIG_arg_fail(1)) SWIG_fail;
23458     result = (int) ((arg1)->m_col);
23459
23460     {
23461         resultobj = SWIG_From_int((int)(result));
23462     }
23463     return resultobj;
23464     fail:
23465     return NULL;
23466 }
23467
23468
23469 static PyObject *_wrap_ListEvent_m_pointDrag_set(PyObject *, PyObject *args, PyObject *kwargs) {
23470     PyObject *resultobj;
23471     wxListEvent *arg1 = (wxListEvent *) 0 ;
23472     wxPoint *arg2 = (wxPoint *) 0 ;
23473     PyObject * obj0 = 0 ;
23474     PyObject * obj1 = 0 ;
23475     char *kwnames[] = {
23476         (char *) "self",(char *) "m_pointDrag", NULL
23477     };
23478
23479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_m_pointDrag_set",kwnames,&obj0,&obj1)) goto fail;
23480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23481     if (SWIG_arg_fail(1)) SWIG_fail;
23482     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
23483     if (SWIG_arg_fail(2)) SWIG_fail;
23484     if (arg1) (arg1)->m_pointDrag = *arg2;
23485
23486     Py_INCREF(Py_None); resultobj = Py_None;
23487     return resultobj;
23488     fail:
23489     return NULL;
23490 }
23491
23492
23493 static PyObject *_wrap_ListEvent_m_pointDrag_get(PyObject *, PyObject *args, PyObject *kwargs) {
23494     PyObject *resultobj;
23495     wxListEvent *arg1 = (wxListEvent *) 0 ;
23496     wxPoint *result;
23497     PyObject * obj0 = 0 ;
23498     char *kwnames[] = {
23499         (char *) "self", NULL
23500     };
23501
23502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_pointDrag_get",kwnames,&obj0)) goto fail;
23503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23504     if (SWIG_arg_fail(1)) SWIG_fail;
23505     result = (wxPoint *)& ((arg1)->m_pointDrag);
23506
23507     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
23508     return resultobj;
23509     fail:
23510     return NULL;
23511 }
23512
23513
23514 static PyObject *_wrap_ListEvent_m_item_get(PyObject *, PyObject *args, PyObject *kwargs) {
23515     PyObject *resultobj;
23516     wxListEvent *arg1 = (wxListEvent *) 0 ;
23517     wxListItem *result;
23518     PyObject * obj0 = 0 ;
23519     char *kwnames[] = {
23520         (char *) "self", NULL
23521     };
23522
23523     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_m_item_get",kwnames,&obj0)) goto fail;
23524     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23525     if (SWIG_arg_fail(1)) SWIG_fail;
23526     result = (wxListItem *)& ((arg1)->m_item);
23527
23528     {
23529         resultobj = wxPyMake_wxObject(result, 0);
23530     }
23531     return resultobj;
23532     fail:
23533     return NULL;
23534 }
23535
23536
23537 static PyObject *_wrap_ListEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23538     PyObject *resultobj;
23539     wxListEvent *arg1 = (wxListEvent *) 0 ;
23540     int result;
23541     PyObject * obj0 = 0 ;
23542     char *kwnames[] = {
23543         (char *) "self", NULL
23544     };
23545
23546     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetKeyCode",kwnames,&obj0)) goto fail;
23547     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23548     if (SWIG_arg_fail(1)) SWIG_fail;
23549     {
23550         PyThreadState* __tstate = wxPyBeginAllowThreads();
23551         result = (int)(arg1)->GetKeyCode();
23552
23553         wxPyEndAllowThreads(__tstate);
23554         if (PyErr_Occurred()) SWIG_fail;
23555     }
23556     {
23557         resultobj = SWIG_From_int((int)(result));
23558     }
23559     return resultobj;
23560     fail:
23561     return NULL;
23562 }
23563
23564
23565 static PyObject *_wrap_ListEvent_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
23566     PyObject *resultobj;
23567     wxListEvent *arg1 = (wxListEvent *) 0 ;
23568     long result;
23569     PyObject * obj0 = 0 ;
23570     char *kwnames[] = {
23571         (char *) "self", NULL
23572     };
23573
23574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetIndex",kwnames,&obj0)) goto fail;
23575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23576     if (SWIG_arg_fail(1)) SWIG_fail;
23577     {
23578         PyThreadState* __tstate = wxPyBeginAllowThreads();
23579         result = (long)(arg1)->GetIndex();
23580
23581         wxPyEndAllowThreads(__tstate);
23582         if (PyErr_Occurred()) SWIG_fail;
23583     }
23584     {
23585         resultobj = SWIG_From_long((long)(result));
23586     }
23587     return resultobj;
23588     fail:
23589     return NULL;
23590 }
23591
23592
23593 static PyObject *_wrap_ListEvent_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
23594     PyObject *resultobj;
23595     wxListEvent *arg1 = (wxListEvent *) 0 ;
23596     int result;
23597     PyObject * obj0 = 0 ;
23598     char *kwnames[] = {
23599         (char *) "self", NULL
23600     };
23601
23602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetColumn",kwnames,&obj0)) goto fail;
23603     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23604     if (SWIG_arg_fail(1)) SWIG_fail;
23605     {
23606         PyThreadState* __tstate = wxPyBeginAllowThreads();
23607         result = (int)(arg1)->GetColumn();
23608
23609         wxPyEndAllowThreads(__tstate);
23610         if (PyErr_Occurred()) SWIG_fail;
23611     }
23612     {
23613         resultobj = SWIG_From_int((int)(result));
23614     }
23615     return resultobj;
23616     fail:
23617     return NULL;
23618 }
23619
23620
23621 static PyObject *_wrap_ListEvent_GetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
23622     PyObject *resultobj;
23623     wxListEvent *arg1 = (wxListEvent *) 0 ;
23624     wxPoint result;
23625     PyObject * obj0 = 0 ;
23626     char *kwnames[] = {
23627         (char *) "self", NULL
23628     };
23629
23630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetPoint",kwnames,&obj0)) goto fail;
23631     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23632     if (SWIG_arg_fail(1)) SWIG_fail;
23633     {
23634         PyThreadState* __tstate = wxPyBeginAllowThreads();
23635         result = (arg1)->GetPoint();
23636
23637         wxPyEndAllowThreads(__tstate);
23638         if (PyErr_Occurred()) SWIG_fail;
23639     }
23640     {
23641         wxPoint * resultptr;
23642         resultptr = new wxPoint((wxPoint &)(result));
23643         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
23644     }
23645     return resultobj;
23646     fail:
23647     return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_ListEvent_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
23652     PyObject *resultobj;
23653     wxListEvent *arg1 = (wxListEvent *) 0 ;
23654     wxString *result;
23655     PyObject * obj0 = 0 ;
23656     char *kwnames[] = {
23657         (char *) "self", NULL
23658     };
23659
23660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetLabel",kwnames,&obj0)) goto fail;
23661     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23662     if (SWIG_arg_fail(1)) SWIG_fail;
23663     {
23664         PyThreadState* __tstate = wxPyBeginAllowThreads();
23665         {
23666             wxString const &_result_ref = (arg1)->GetLabel();
23667             result = (wxString *) &_result_ref;
23668         }
23669
23670         wxPyEndAllowThreads(__tstate);
23671         if (PyErr_Occurred()) SWIG_fail;
23672     }
23673     {
23674 #if wxUSE_UNICODE
23675         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23676 #else
23677         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23678 #endif
23679     }
23680     return resultobj;
23681     fail:
23682     return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_ListEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
23687     PyObject *resultobj;
23688     wxListEvent *arg1 = (wxListEvent *) 0 ;
23689     wxString *result;
23690     PyObject * obj0 = 0 ;
23691     char *kwnames[] = {
23692         (char *) "self", NULL
23693     };
23694
23695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetText",kwnames,&obj0)) goto fail;
23696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23697     if (SWIG_arg_fail(1)) SWIG_fail;
23698     {
23699         PyThreadState* __tstate = wxPyBeginAllowThreads();
23700         {
23701             wxString const &_result_ref = (arg1)->GetText();
23702             result = (wxString *) &_result_ref;
23703         }
23704
23705         wxPyEndAllowThreads(__tstate);
23706         if (PyErr_Occurred()) SWIG_fail;
23707     }
23708     {
23709 #if wxUSE_UNICODE
23710         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23711 #else
23712         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23713 #endif
23714     }
23715     return resultobj;
23716     fail:
23717     return NULL;
23718 }
23719
23720
23721 static PyObject *_wrap_ListEvent_GetImage(PyObject *, PyObject *args, PyObject *kwargs) {
23722     PyObject *resultobj;
23723     wxListEvent *arg1 = (wxListEvent *) 0 ;
23724     int result;
23725     PyObject * obj0 = 0 ;
23726     char *kwnames[] = {
23727         (char *) "self", NULL
23728     };
23729
23730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetImage",kwnames,&obj0)) goto fail;
23731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23732     if (SWIG_arg_fail(1)) SWIG_fail;
23733     {
23734         PyThreadState* __tstate = wxPyBeginAllowThreads();
23735         result = (int)(arg1)->GetImage();
23736
23737         wxPyEndAllowThreads(__tstate);
23738         if (PyErr_Occurred()) SWIG_fail;
23739     }
23740     {
23741         resultobj = SWIG_From_int((int)(result));
23742     }
23743     return resultobj;
23744     fail:
23745     return NULL;
23746 }
23747
23748
23749 static PyObject *_wrap_ListEvent_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
23750     PyObject *resultobj;
23751     wxListEvent *arg1 = (wxListEvent *) 0 ;
23752     long result;
23753     PyObject * obj0 = 0 ;
23754     char *kwnames[] = {
23755         (char *) "self", NULL
23756     };
23757
23758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetData",kwnames,&obj0)) goto fail;
23759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23760     if (SWIG_arg_fail(1)) SWIG_fail;
23761     {
23762         PyThreadState* __tstate = wxPyBeginAllowThreads();
23763         result = (long)(arg1)->GetData();
23764
23765         wxPyEndAllowThreads(__tstate);
23766         if (PyErr_Occurred()) SWIG_fail;
23767     }
23768     {
23769         resultobj = SWIG_From_long((long)(result));
23770     }
23771     return resultobj;
23772     fail:
23773     return NULL;
23774 }
23775
23776
23777 static PyObject *_wrap_ListEvent_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
23778     PyObject *resultobj;
23779     wxListEvent *arg1 = (wxListEvent *) 0 ;
23780     long result;
23781     PyObject * obj0 = 0 ;
23782     char *kwnames[] = {
23783         (char *) "self", NULL
23784     };
23785
23786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetMask",kwnames,&obj0)) goto fail;
23787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23788     if (SWIG_arg_fail(1)) SWIG_fail;
23789     {
23790         PyThreadState* __tstate = wxPyBeginAllowThreads();
23791         result = (long)(arg1)->GetMask();
23792
23793         wxPyEndAllowThreads(__tstate);
23794         if (PyErr_Occurred()) SWIG_fail;
23795     }
23796     {
23797         resultobj = SWIG_From_long((long)(result));
23798     }
23799     return resultobj;
23800     fail:
23801     return NULL;
23802 }
23803
23804
23805 static PyObject *_wrap_ListEvent_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
23806     PyObject *resultobj;
23807     wxListEvent *arg1 = (wxListEvent *) 0 ;
23808     wxListItem *result;
23809     PyObject * obj0 = 0 ;
23810     char *kwnames[] = {
23811         (char *) "self", NULL
23812     };
23813
23814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetItem",kwnames,&obj0)) goto fail;
23815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23816     if (SWIG_arg_fail(1)) SWIG_fail;
23817     {
23818         PyThreadState* __tstate = wxPyBeginAllowThreads();
23819         {
23820             wxListItem const &_result_ref = (arg1)->GetItem();
23821             result = (wxListItem *) &_result_ref;
23822         }
23823
23824         wxPyEndAllowThreads(__tstate);
23825         if (PyErr_Occurred()) SWIG_fail;
23826     }
23827     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListItem, 0);
23828     return resultobj;
23829     fail:
23830     return NULL;
23831 }
23832
23833
23834 static PyObject *_wrap_ListEvent_GetCacheFrom(PyObject *, PyObject *args, PyObject *kwargs) {
23835     PyObject *resultobj;
23836     wxListEvent *arg1 = (wxListEvent *) 0 ;
23837     long result;
23838     PyObject * obj0 = 0 ;
23839     char *kwnames[] = {
23840         (char *) "self", NULL
23841     };
23842
23843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetCacheFrom",kwnames,&obj0)) goto fail;
23844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23845     if (SWIG_arg_fail(1)) SWIG_fail;
23846     {
23847         PyThreadState* __tstate = wxPyBeginAllowThreads();
23848         result = (long)(arg1)->GetCacheFrom();
23849
23850         wxPyEndAllowThreads(__tstate);
23851         if (PyErr_Occurred()) SWIG_fail;
23852     }
23853     {
23854         resultobj = SWIG_From_long((long)(result));
23855     }
23856     return resultobj;
23857     fail:
23858     return NULL;
23859 }
23860
23861
23862 static PyObject *_wrap_ListEvent_GetCacheTo(PyObject *, PyObject *args, PyObject *kwargs) {
23863     PyObject *resultobj;
23864     wxListEvent *arg1 = (wxListEvent *) 0 ;
23865     long result;
23866     PyObject * obj0 = 0 ;
23867     char *kwnames[] = {
23868         (char *) "self", NULL
23869     };
23870
23871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_GetCacheTo",kwnames,&obj0)) goto fail;
23872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23873     if (SWIG_arg_fail(1)) SWIG_fail;
23874     {
23875         PyThreadState* __tstate = wxPyBeginAllowThreads();
23876         result = (long)(arg1)->GetCacheTo();
23877
23878         wxPyEndAllowThreads(__tstate);
23879         if (PyErr_Occurred()) SWIG_fail;
23880     }
23881     {
23882         resultobj = SWIG_From_long((long)(result));
23883     }
23884     return resultobj;
23885     fail:
23886     return NULL;
23887 }
23888
23889
23890 static PyObject *_wrap_ListEvent_IsEditCancelled(PyObject *, PyObject *args, PyObject *kwargs) {
23891     PyObject *resultobj;
23892     wxListEvent *arg1 = (wxListEvent *) 0 ;
23893     bool result;
23894     PyObject * obj0 = 0 ;
23895     char *kwnames[] = {
23896         (char *) "self", NULL
23897     };
23898
23899     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListEvent_IsEditCancelled",kwnames,&obj0)) goto fail;
23900     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23901     if (SWIG_arg_fail(1)) SWIG_fail;
23902     {
23903         PyThreadState* __tstate = wxPyBeginAllowThreads();
23904         result = (bool)((wxListEvent const *)arg1)->IsEditCancelled();
23905
23906         wxPyEndAllowThreads(__tstate);
23907         if (PyErr_Occurred()) SWIG_fail;
23908     }
23909     {
23910         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23911     }
23912     return resultobj;
23913     fail:
23914     return NULL;
23915 }
23916
23917
23918 static PyObject *_wrap_ListEvent_SetEditCanceled(PyObject *, PyObject *args, PyObject *kwargs) {
23919     PyObject *resultobj;
23920     wxListEvent *arg1 = (wxListEvent *) 0 ;
23921     bool arg2 ;
23922     PyObject * obj0 = 0 ;
23923     PyObject * obj1 = 0 ;
23924     char *kwnames[] = {
23925         (char *) "self",(char *) "editCancelled", NULL
23926     };
23927
23928     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_SetEditCanceled",kwnames,&obj0,&obj1)) goto fail;
23929     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListEvent, SWIG_POINTER_EXCEPTION | 0);
23930     if (SWIG_arg_fail(1)) SWIG_fail;
23931     {
23932         arg2 = (bool)(SWIG_As_bool(obj1));
23933         if (SWIG_arg_fail(2)) SWIG_fail;
23934     }
23935     {
23936         PyThreadState* __tstate = wxPyBeginAllowThreads();
23937         (arg1)->SetEditCanceled(arg2);
23938
23939         wxPyEndAllowThreads(__tstate);
23940         if (PyErr_Occurred()) SWIG_fail;
23941     }
23942     Py_INCREF(Py_None); resultobj = Py_None;
23943     return resultobj;
23944     fail:
23945     return NULL;
23946 }
23947
23948
23949 static PyObject * ListEvent_swigregister(PyObject *, PyObject *args) {
23950     PyObject *obj;
23951     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23952     SWIG_TypeClientData(SWIGTYPE_p_wxListEvent, obj);
23953     Py_INCREF(obj);
23954     return Py_BuildValue((char *)"");
23955 }
23956 static PyObject *_wrap_new_ListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
23957     PyObject *resultobj;
23958     wxWindow *arg1 = (wxWindow *) 0 ;
23959     int arg2 = (int) -1 ;
23960     wxPoint const &arg3_defvalue = wxDefaultPosition ;
23961     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
23962     wxSize const &arg4_defvalue = wxDefaultSize ;
23963     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
23964     long arg5 = (long) wxLC_ICON ;
23965     wxValidator const &arg6_defvalue = wxDefaultValidator ;
23966     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
23967     wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
23968     wxString *arg7 = (wxString *) &arg7_defvalue ;
23969     wxPyListCtrl *result;
23970     wxPoint temp3 ;
23971     wxSize temp4 ;
23972     bool temp7 = false ;
23973     PyObject * obj0 = 0 ;
23974     PyObject * obj1 = 0 ;
23975     PyObject * obj2 = 0 ;
23976     PyObject * obj3 = 0 ;
23977     PyObject * obj4 = 0 ;
23978     PyObject * obj5 = 0 ;
23979     PyObject * obj6 = 0 ;
23980     char *kwnames[] = {
23981         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
23982     };
23983
23984     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
23985     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23986     if (SWIG_arg_fail(1)) SWIG_fail;
23987     if (obj1) {
23988         {
23989             arg2 = (int)(SWIG_As_int(obj1));
23990             if (SWIG_arg_fail(2)) SWIG_fail;
23991         }
23992     }
23993     if (obj2) {
23994         {
23995             arg3 = &temp3;
23996             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
23997         }
23998     }
23999     if (obj3) {
24000         {
24001             arg4 = &temp4;
24002             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24003         }
24004     }
24005     if (obj4) {
24006         {
24007             arg5 = (long)(SWIG_As_long(obj4));
24008             if (SWIG_arg_fail(5)) SWIG_fail;
24009         }
24010     }
24011     if (obj5) {
24012         {
24013             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
24014             if (SWIG_arg_fail(6)) SWIG_fail;
24015             if (arg6 == NULL) {
24016                 SWIG_null_ref("wxValidator");
24017             }
24018             if (SWIG_arg_fail(6)) SWIG_fail;
24019         }
24020     }
24021     if (obj6) {
24022         {
24023             arg7 = wxString_in_helper(obj6);
24024             if (arg7 == NULL) SWIG_fail;
24025             temp7 = true;
24026         }
24027     }
24028     {
24029         if (!wxPyCheckForApp()) SWIG_fail;
24030         PyThreadState* __tstate = wxPyBeginAllowThreads();
24031         result = (wxPyListCtrl *)new wxPyListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
24032
24033         wxPyEndAllowThreads(__tstate);
24034         if (PyErr_Occurred()) SWIG_fail;
24035     }
24036     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyListCtrl, 1);
24037     {
24038         if (temp7)
24039         delete arg7;
24040     }
24041     return resultobj;
24042     fail:
24043     {
24044         if (temp7)
24045         delete arg7;
24046     }
24047     return NULL;
24048 }
24049
24050
24051 static PyObject *_wrap_new_PreListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
24052     PyObject *resultobj;
24053     wxPyListCtrl *result;
24054     char *kwnames[] = {
24055         NULL
24056     };
24057
24058     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListCtrl",kwnames)) goto fail;
24059     {
24060         if (!wxPyCheckForApp()) SWIG_fail;
24061         PyThreadState* __tstate = wxPyBeginAllowThreads();
24062         result = (wxPyListCtrl *)new wxPyListCtrl();
24063
24064         wxPyEndAllowThreads(__tstate);
24065         if (PyErr_Occurred()) SWIG_fail;
24066     }
24067     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyListCtrl, 1);
24068     return resultobj;
24069     fail:
24070     return NULL;
24071 }
24072
24073
24074 static PyObject *_wrap_ListCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24075     PyObject *resultobj;
24076     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24077     wxWindow *arg2 = (wxWindow *) 0 ;
24078     int arg3 = (int) -1 ;
24079     wxPoint const &arg4_defvalue = wxDefaultPosition ;
24080     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24081     wxSize const &arg5_defvalue = wxDefaultSize ;
24082     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24083     long arg6 = (long) wxLC_ICON ;
24084     wxValidator const &arg7_defvalue = wxDefaultValidator ;
24085     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
24086     wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
24087     wxString *arg8 = (wxString *) &arg8_defvalue ;
24088     bool result;
24089     wxPoint temp4 ;
24090     wxSize temp5 ;
24091     bool temp8 = false ;
24092     PyObject * obj0 = 0 ;
24093     PyObject * obj1 = 0 ;
24094     PyObject * obj2 = 0 ;
24095     PyObject * obj3 = 0 ;
24096     PyObject * obj4 = 0 ;
24097     PyObject * obj5 = 0 ;
24098     PyObject * obj6 = 0 ;
24099     PyObject * obj7 = 0 ;
24100     char *kwnames[] = {
24101         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
24102     };
24103
24104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
24105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24106     if (SWIG_arg_fail(1)) SWIG_fail;
24107     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24108     if (SWIG_arg_fail(2)) SWIG_fail;
24109     if (obj2) {
24110         {
24111             arg3 = (int)(SWIG_As_int(obj2));
24112             if (SWIG_arg_fail(3)) SWIG_fail;
24113         }
24114     }
24115     if (obj3) {
24116         {
24117             arg4 = &temp4;
24118             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24119         }
24120     }
24121     if (obj4) {
24122         {
24123             arg5 = &temp5;
24124             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24125         }
24126     }
24127     if (obj5) {
24128         {
24129             arg6 = (long)(SWIG_As_long(obj5));
24130             if (SWIG_arg_fail(6)) SWIG_fail;
24131         }
24132     }
24133     if (obj6) {
24134         {
24135             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
24136             if (SWIG_arg_fail(7)) SWIG_fail;
24137             if (arg7 == NULL) {
24138                 SWIG_null_ref("wxValidator");
24139             }
24140             if (SWIG_arg_fail(7)) SWIG_fail;
24141         }
24142     }
24143     if (obj7) {
24144         {
24145             arg8 = wxString_in_helper(obj7);
24146             if (arg8 == NULL) SWIG_fail;
24147             temp8 = true;
24148         }
24149     }
24150     {
24151         PyThreadState* __tstate = wxPyBeginAllowThreads();
24152         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
24153
24154         wxPyEndAllowThreads(__tstate);
24155         if (PyErr_Occurred()) SWIG_fail;
24156     }
24157     {
24158         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24159     }
24160     {
24161         if (temp8)
24162         delete arg8;
24163     }
24164     return resultobj;
24165     fail:
24166     {
24167         if (temp8)
24168         delete arg8;
24169     }
24170     return NULL;
24171 }
24172
24173
24174 static PyObject *_wrap_ListCtrl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24175     PyObject *resultobj;
24176     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24177     PyObject *arg2 = (PyObject *) 0 ;
24178     PyObject *arg3 = (PyObject *) 0 ;
24179     PyObject * obj0 = 0 ;
24180     PyObject * obj1 = 0 ;
24181     PyObject * obj2 = 0 ;
24182     char *kwnames[] = {
24183         (char *) "self",(char *) "self",(char *) "_class", NULL
24184     };
24185
24186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24187     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24188     if (SWIG_arg_fail(1)) SWIG_fail;
24189     arg2 = obj1;
24190     arg3 = obj2;
24191     {
24192         PyThreadState* __tstate = wxPyBeginAllowThreads();
24193         (arg1)->_setCallbackInfo(arg2,arg3);
24194
24195         wxPyEndAllowThreads(__tstate);
24196         if (PyErr_Occurred()) SWIG_fail;
24197     }
24198     Py_INCREF(Py_None); resultobj = Py_None;
24199     return resultobj;
24200     fail:
24201     return NULL;
24202 }
24203
24204
24205 static PyObject *_wrap_ListCtrl_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
24206     PyObject *resultobj;
24207     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24208     wxColour *arg2 = 0 ;
24209     bool result;
24210     wxColour temp2 ;
24211     PyObject * obj0 = 0 ;
24212     PyObject * obj1 = 0 ;
24213     char *kwnames[] = {
24214         (char *) "self",(char *) "col", NULL
24215     };
24216
24217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
24218     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24219     if (SWIG_arg_fail(1)) SWIG_fail;
24220     {
24221         arg2 = &temp2;
24222         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24223     }
24224     {
24225         PyThreadState* __tstate = wxPyBeginAllowThreads();
24226         result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
24227
24228         wxPyEndAllowThreads(__tstate);
24229         if (PyErr_Occurred()) SWIG_fail;
24230     }
24231     {
24232         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24233     }
24234     return resultobj;
24235     fail:
24236     return NULL;
24237 }
24238
24239
24240 static PyObject *_wrap_ListCtrl_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
24241     PyObject *resultobj;
24242     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24243     wxColour *arg2 = 0 ;
24244     bool result;
24245     wxColour temp2 ;
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_SetBackgroundColour",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 = &temp2;
24257         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24258     }
24259     {
24260         PyThreadState* __tstate = wxPyBeginAllowThreads();
24261         result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
24262
24263         wxPyEndAllowThreads(__tstate);
24264         if (PyErr_Occurred()) SWIG_fail;
24265     }
24266     {
24267         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24268     }
24269     return resultobj;
24270     fail:
24271     return NULL;
24272 }
24273
24274
24275 static PyObject *_wrap_ListCtrl_GetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
24276     PyObject *resultobj;
24277     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24278     int arg2 ;
24279     wxListItem *result;
24280     PyObject * obj0 = 0 ;
24281     PyObject * obj1 = 0 ;
24282     char *kwnames[] = {
24283         (char *) "self",(char *) "col", NULL
24284     };
24285
24286     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumn",kwnames,&obj0,&obj1)) goto fail;
24287     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24288     if (SWIG_arg_fail(1)) SWIG_fail;
24289     {
24290         arg2 = (int)(SWIG_As_int(obj1));
24291         if (SWIG_arg_fail(2)) SWIG_fail;
24292     }
24293     {
24294         PyThreadState* __tstate = wxPyBeginAllowThreads();
24295         result = (wxListItem *)wxPyListCtrl_GetColumn(arg1,arg2);
24296
24297         wxPyEndAllowThreads(__tstate);
24298         if (PyErr_Occurred()) SWIG_fail;
24299     }
24300     {
24301         resultobj = wxPyMake_wxObject(result, 0);
24302     }
24303     return resultobj;
24304     fail:
24305     return NULL;
24306 }
24307
24308
24309 static PyObject *_wrap_ListCtrl_SetColumn(PyObject *, PyObject *args, PyObject *kwargs) {
24310     PyObject *resultobj;
24311     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24312     int arg2 ;
24313     wxListItem *arg3 = 0 ;
24314     bool result;
24315     PyObject * obj0 = 0 ;
24316     PyObject * obj1 = 0 ;
24317     PyObject * obj2 = 0 ;
24318     char *kwnames[] = {
24319         (char *) "self",(char *) "col",(char *) "item", NULL
24320     };
24321
24322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
24323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24324     if (SWIG_arg_fail(1)) SWIG_fail;
24325     {
24326         arg2 = (int)(SWIG_As_int(obj1));
24327         if (SWIG_arg_fail(2)) SWIG_fail;
24328     }
24329     {
24330         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
24331         if (SWIG_arg_fail(3)) SWIG_fail;
24332         if (arg3 == NULL) {
24333             SWIG_null_ref("wxListItem");
24334         }
24335         if (SWIG_arg_fail(3)) SWIG_fail;
24336     }
24337     {
24338         PyThreadState* __tstate = wxPyBeginAllowThreads();
24339         result = (bool)(arg1)->SetColumn(arg2,*arg3);
24340
24341         wxPyEndAllowThreads(__tstate);
24342         if (PyErr_Occurred()) SWIG_fail;
24343     }
24344     {
24345         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24346     }
24347     return resultobj;
24348     fail:
24349     return NULL;
24350 }
24351
24352
24353 static PyObject *_wrap_ListCtrl_GetColumnWidth(PyObject *, PyObject *args, PyObject *kwargs) {
24354     PyObject *resultobj;
24355     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24356     int arg2 ;
24357     int result;
24358     PyObject * obj0 = 0 ;
24359     PyObject * obj1 = 0 ;
24360     char *kwnames[] = {
24361         (char *) "self",(char *) "col", NULL
24362     };
24363
24364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumnWidth",kwnames,&obj0,&obj1)) goto fail;
24365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24366     if (SWIG_arg_fail(1)) SWIG_fail;
24367     {
24368         arg2 = (int)(SWIG_As_int(obj1));
24369         if (SWIG_arg_fail(2)) SWIG_fail;
24370     }
24371     {
24372         PyThreadState* __tstate = wxPyBeginAllowThreads();
24373         result = (int)((wxPyListCtrl const *)arg1)->GetColumnWidth(arg2);
24374
24375         wxPyEndAllowThreads(__tstate);
24376         if (PyErr_Occurred()) SWIG_fail;
24377     }
24378     {
24379         resultobj = SWIG_From_int((int)(result));
24380     }
24381     return resultobj;
24382     fail:
24383     return NULL;
24384 }
24385
24386
24387 static PyObject *_wrap_ListCtrl_SetColumnWidth(PyObject *, PyObject *args, PyObject *kwargs) {
24388     PyObject *resultobj;
24389     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24390     int arg2 ;
24391     int arg3 ;
24392     bool result;
24393     PyObject * obj0 = 0 ;
24394     PyObject * obj1 = 0 ;
24395     PyObject * obj2 = 0 ;
24396     char *kwnames[] = {
24397         (char *) "self",(char *) "col",(char *) "width", NULL
24398     };
24399
24400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumnWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
24401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24402     if (SWIG_arg_fail(1)) SWIG_fail;
24403     {
24404         arg2 = (int)(SWIG_As_int(obj1));
24405         if (SWIG_arg_fail(2)) SWIG_fail;
24406     }
24407     {
24408         arg3 = (int)(SWIG_As_int(obj2));
24409         if (SWIG_arg_fail(3)) SWIG_fail;
24410     }
24411     {
24412         PyThreadState* __tstate = wxPyBeginAllowThreads();
24413         result = (bool)(arg1)->SetColumnWidth(arg2,arg3);
24414
24415         wxPyEndAllowThreads(__tstate);
24416         if (PyErr_Occurred()) SWIG_fail;
24417     }
24418     {
24419         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24420     }
24421     return resultobj;
24422     fail:
24423     return NULL;
24424 }
24425
24426
24427 static PyObject *_wrap_ListCtrl_GetCountPerPage(PyObject *, PyObject *args, PyObject *kwargs) {
24428     PyObject *resultobj;
24429     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24430     int result;
24431     PyObject * obj0 = 0 ;
24432     char *kwnames[] = {
24433         (char *) "self", NULL
24434     };
24435
24436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetCountPerPage",kwnames,&obj0)) goto fail;
24437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24438     if (SWIG_arg_fail(1)) SWIG_fail;
24439     {
24440         PyThreadState* __tstate = wxPyBeginAllowThreads();
24441         result = (int)((wxPyListCtrl const *)arg1)->GetCountPerPage();
24442
24443         wxPyEndAllowThreads(__tstate);
24444         if (PyErr_Occurred()) SWIG_fail;
24445     }
24446     {
24447         resultobj = SWIG_From_int((int)(result));
24448     }
24449     return resultobj;
24450     fail:
24451     return NULL;
24452 }
24453
24454
24455 static PyObject *_wrap_ListCtrl_GetViewRect(PyObject *, PyObject *args, PyObject *kwargs) {
24456     PyObject *resultobj;
24457     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24458     wxRect result;
24459     PyObject * obj0 = 0 ;
24460     char *kwnames[] = {
24461         (char *) "self", NULL
24462     };
24463
24464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetViewRect",kwnames,&obj0)) goto fail;
24465     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24466     if (SWIG_arg_fail(1)) SWIG_fail;
24467     {
24468         PyThreadState* __tstate = wxPyBeginAllowThreads();
24469         result = ((wxPyListCtrl const *)arg1)->GetViewRect();
24470
24471         wxPyEndAllowThreads(__tstate);
24472         if (PyErr_Occurred()) SWIG_fail;
24473     }
24474     {
24475         wxRect * resultptr;
24476         resultptr = new wxRect((wxRect &)(result));
24477         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
24478     }
24479     return resultobj;
24480     fail:
24481     return NULL;
24482 }
24483
24484
24485 static PyObject *_wrap_ListCtrl_GetEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
24486     PyObject *resultobj;
24487     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24488     wxTextCtrl *result;
24489     PyObject * obj0 = 0 ;
24490     char *kwnames[] = {
24491         (char *) "self", NULL
24492     };
24493
24494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetEditControl",kwnames,&obj0)) goto fail;
24495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24496     if (SWIG_arg_fail(1)) SWIG_fail;
24497     {
24498         PyThreadState* __tstate = wxPyBeginAllowThreads();
24499         result = (wxTextCtrl *)((wxPyListCtrl const *)arg1)->GetEditControl();
24500
24501         wxPyEndAllowThreads(__tstate);
24502         if (PyErr_Occurred()) SWIG_fail;
24503     }
24504     {
24505         resultobj = wxPyMake_wxObject(result, 0);
24506     }
24507     return resultobj;
24508     fail:
24509     return NULL;
24510 }
24511
24512
24513 static PyObject *_wrap_ListCtrl_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
24514     PyObject *resultobj;
24515     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24516     long arg2 ;
24517     int arg3 = (int) 0 ;
24518     wxListItem *result;
24519     PyObject * obj0 = 0 ;
24520     PyObject * obj1 = 0 ;
24521     PyObject * obj2 = 0 ;
24522     char *kwnames[] = {
24523         (char *) "self",(char *) "itemId",(char *) "col", NULL
24524     };
24525
24526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
24527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24528     if (SWIG_arg_fail(1)) SWIG_fail;
24529     {
24530         arg2 = (long)(SWIG_As_long(obj1));
24531         if (SWIG_arg_fail(2)) SWIG_fail;
24532     }
24533     if (obj2) {
24534         {
24535             arg3 = (int)(SWIG_As_int(obj2));
24536             if (SWIG_arg_fail(3)) SWIG_fail;
24537         }
24538     }
24539     {
24540         PyThreadState* __tstate = wxPyBeginAllowThreads();
24541         result = (wxListItem *)wxPyListCtrl_GetItem(arg1,arg2,arg3);
24542
24543         wxPyEndAllowThreads(__tstate);
24544         if (PyErr_Occurred()) SWIG_fail;
24545     }
24546     {
24547         resultobj = wxPyMake_wxObject(result, 0);
24548     }
24549     return resultobj;
24550     fail:
24551     return NULL;
24552 }
24553
24554
24555 static PyObject *_wrap_ListCtrl_SetItem(PyObject *, PyObject *args, PyObject *kwargs) {
24556     PyObject *resultobj;
24557     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24558     wxListItem *arg2 = 0 ;
24559     bool result;
24560     PyObject * obj0 = 0 ;
24561     PyObject * obj1 = 0 ;
24562     char *kwnames[] = {
24563         (char *) "self",(char *) "info", NULL
24564     };
24565
24566     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItem",kwnames,&obj0,&obj1)) goto fail;
24567     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24568     if (SWIG_arg_fail(1)) SWIG_fail;
24569     {
24570         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
24571         if (SWIG_arg_fail(2)) SWIG_fail;
24572         if (arg2 == NULL) {
24573             SWIG_null_ref("wxListItem");
24574         }
24575         if (SWIG_arg_fail(2)) SWIG_fail;
24576     }
24577     {
24578         PyThreadState* __tstate = wxPyBeginAllowThreads();
24579         result = (bool)(arg1)->SetItem(*arg2);
24580
24581         wxPyEndAllowThreads(__tstate);
24582         if (PyErr_Occurred()) SWIG_fail;
24583     }
24584     {
24585         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24586     }
24587     return resultobj;
24588     fail:
24589     return NULL;
24590 }
24591
24592
24593 static PyObject *_wrap_ListCtrl_SetStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
24594     PyObject *resultobj;
24595     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24596     long arg2 ;
24597     int arg3 ;
24598     wxString *arg4 = 0 ;
24599     int arg5 = (int) -1 ;
24600     long result;
24601     bool temp4 = false ;
24602     PyObject * obj0 = 0 ;
24603     PyObject * obj1 = 0 ;
24604     PyObject * obj2 = 0 ;
24605     PyObject * obj3 = 0 ;
24606     PyObject * obj4 = 0 ;
24607     char *kwnames[] = {
24608         (char *) "self",(char *) "index",(char *) "col",(char *) "label",(char *) "imageId", NULL
24609     };
24610
24611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:ListCtrl_SetStringItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
24612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24613     if (SWIG_arg_fail(1)) SWIG_fail;
24614     {
24615         arg2 = (long)(SWIG_As_long(obj1));
24616         if (SWIG_arg_fail(2)) SWIG_fail;
24617     }
24618     {
24619         arg3 = (int)(SWIG_As_int(obj2));
24620         if (SWIG_arg_fail(3)) SWIG_fail;
24621     }
24622     {
24623         arg4 = wxString_in_helper(obj3);
24624         if (arg4 == NULL) SWIG_fail;
24625         temp4 = true;
24626     }
24627     if (obj4) {
24628         {
24629             arg5 = (int)(SWIG_As_int(obj4));
24630             if (SWIG_arg_fail(5)) SWIG_fail;
24631         }
24632     }
24633     {
24634         PyThreadState* __tstate = wxPyBeginAllowThreads();
24635         result = (long)(arg1)->SetItem(arg2,arg3,(wxString const &)*arg4,arg5);
24636
24637         wxPyEndAllowThreads(__tstate);
24638         if (PyErr_Occurred()) SWIG_fail;
24639     }
24640     {
24641         resultobj = SWIG_From_long((long)(result));
24642     }
24643     {
24644         if (temp4)
24645         delete arg4;
24646     }
24647     return resultobj;
24648     fail:
24649     {
24650         if (temp4)
24651         delete arg4;
24652     }
24653     return NULL;
24654 }
24655
24656
24657 static PyObject *_wrap_ListCtrl_GetItemState(PyObject *, PyObject *args, PyObject *kwargs) {
24658     PyObject *resultobj;
24659     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24660     long arg2 ;
24661     long arg3 ;
24662     int result;
24663     PyObject * obj0 = 0 ;
24664     PyObject * obj1 = 0 ;
24665     PyObject * obj2 = 0 ;
24666     char *kwnames[] = {
24667         (char *) "self",(char *) "item",(char *) "stateMask", NULL
24668     };
24669
24670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_GetItemState",kwnames,&obj0,&obj1,&obj2)) goto fail;
24671     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24672     if (SWIG_arg_fail(1)) SWIG_fail;
24673     {
24674         arg2 = (long)(SWIG_As_long(obj1));
24675         if (SWIG_arg_fail(2)) SWIG_fail;
24676     }
24677     {
24678         arg3 = (long)(SWIG_As_long(obj2));
24679         if (SWIG_arg_fail(3)) SWIG_fail;
24680     }
24681     {
24682         PyThreadState* __tstate = wxPyBeginAllowThreads();
24683         result = (int)((wxPyListCtrl const *)arg1)->GetItemState(arg2,arg3);
24684
24685         wxPyEndAllowThreads(__tstate);
24686         if (PyErr_Occurred()) SWIG_fail;
24687     }
24688     {
24689         resultobj = SWIG_From_int((int)(result));
24690     }
24691     return resultobj;
24692     fail:
24693     return NULL;
24694 }
24695
24696
24697 static PyObject *_wrap_ListCtrl_SetItemState(PyObject *, PyObject *args, PyObject *kwargs) {
24698     PyObject *resultobj;
24699     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24700     long arg2 ;
24701     long arg3 ;
24702     long arg4 ;
24703     bool result;
24704     PyObject * obj0 = 0 ;
24705     PyObject * obj1 = 0 ;
24706     PyObject * obj2 = 0 ;
24707     PyObject * obj3 = 0 ;
24708     char *kwnames[] = {
24709         (char *) "self",(char *) "item",(char *) "state",(char *) "stateMask", NULL
24710     };
24711
24712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_SetItemState",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24714     if (SWIG_arg_fail(1)) SWIG_fail;
24715     {
24716         arg2 = (long)(SWIG_As_long(obj1));
24717         if (SWIG_arg_fail(2)) SWIG_fail;
24718     }
24719     {
24720         arg3 = (long)(SWIG_As_long(obj2));
24721         if (SWIG_arg_fail(3)) SWIG_fail;
24722     }
24723     {
24724         arg4 = (long)(SWIG_As_long(obj3));
24725         if (SWIG_arg_fail(4)) SWIG_fail;
24726     }
24727     {
24728         PyThreadState* __tstate = wxPyBeginAllowThreads();
24729         result = (bool)(arg1)->SetItemState(arg2,arg3,arg4);
24730
24731         wxPyEndAllowThreads(__tstate);
24732         if (PyErr_Occurred()) SWIG_fail;
24733     }
24734     {
24735         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24736     }
24737     return resultobj;
24738     fail:
24739     return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_ListCtrl_SetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
24744     PyObject *resultobj;
24745     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24746     long arg2 ;
24747     int arg3 ;
24748     int arg4 = (int) -1 ;
24749     bool result;
24750     PyObject * obj0 = 0 ;
24751     PyObject * obj1 = 0 ;
24752     PyObject * obj2 = 0 ;
24753     PyObject * obj3 = 0 ;
24754     char *kwnames[] = {
24755         (char *) "self",(char *) "item",(char *) "image",(char *) "selImage", NULL
24756     };
24757
24758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24760     if (SWIG_arg_fail(1)) SWIG_fail;
24761     {
24762         arg2 = (long)(SWIG_As_long(obj1));
24763         if (SWIG_arg_fail(2)) SWIG_fail;
24764     }
24765     {
24766         arg3 = (int)(SWIG_As_int(obj2));
24767         if (SWIG_arg_fail(3)) SWIG_fail;
24768     }
24769     if (obj3) {
24770         {
24771             arg4 = (int)(SWIG_As_int(obj3));
24772             if (SWIG_arg_fail(4)) SWIG_fail;
24773         }
24774     }
24775     {
24776         PyThreadState* __tstate = wxPyBeginAllowThreads();
24777         result = (bool)(arg1)->SetItemImage(arg2,arg3,arg4);
24778
24779         wxPyEndAllowThreads(__tstate);
24780         if (PyErr_Occurred()) SWIG_fail;
24781     }
24782     {
24783         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24784     }
24785     return resultobj;
24786     fail:
24787     return NULL;
24788 }
24789
24790
24791 static PyObject *_wrap_ListCtrl_GetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
24792     PyObject *resultobj;
24793     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24794     long arg2 ;
24795     wxString result;
24796     PyObject * obj0 = 0 ;
24797     PyObject * obj1 = 0 ;
24798     char *kwnames[] = {
24799         (char *) "self",(char *) "item", NULL
24800     };
24801
24802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemText",kwnames,&obj0,&obj1)) goto fail;
24803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24804     if (SWIG_arg_fail(1)) SWIG_fail;
24805     {
24806         arg2 = (long)(SWIG_As_long(obj1));
24807         if (SWIG_arg_fail(2)) SWIG_fail;
24808     }
24809     {
24810         PyThreadState* __tstate = wxPyBeginAllowThreads();
24811         result = ((wxPyListCtrl const *)arg1)->GetItemText(arg2);
24812
24813         wxPyEndAllowThreads(__tstate);
24814         if (PyErr_Occurred()) SWIG_fail;
24815     }
24816     {
24817 #if wxUSE_UNICODE
24818         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24819 #else
24820         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24821 #endif
24822     }
24823     return resultobj;
24824     fail:
24825     return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_ListCtrl_SetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
24830     PyObject *resultobj;
24831     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24832     long arg2 ;
24833     wxString *arg3 = 0 ;
24834     bool temp3 = false ;
24835     PyObject * obj0 = 0 ;
24836     PyObject * obj1 = 0 ;
24837     PyObject * obj2 = 0 ;
24838     char *kwnames[] = {
24839         (char *) "self",(char *) "item",(char *) "str", NULL
24840     };
24841
24842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) goto fail;
24843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24844     if (SWIG_arg_fail(1)) SWIG_fail;
24845     {
24846         arg2 = (long)(SWIG_As_long(obj1));
24847         if (SWIG_arg_fail(2)) SWIG_fail;
24848     }
24849     {
24850         arg3 = wxString_in_helper(obj2);
24851         if (arg3 == NULL) SWIG_fail;
24852         temp3 = true;
24853     }
24854     {
24855         PyThreadState* __tstate = wxPyBeginAllowThreads();
24856         (arg1)->SetItemText(arg2,(wxString const &)*arg3);
24857
24858         wxPyEndAllowThreads(__tstate);
24859         if (PyErr_Occurred()) SWIG_fail;
24860     }
24861     Py_INCREF(Py_None); resultobj = Py_None;
24862     {
24863         if (temp3)
24864         delete arg3;
24865     }
24866     return resultobj;
24867     fail:
24868     {
24869         if (temp3)
24870         delete arg3;
24871     }
24872     return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_ListCtrl_GetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
24877     PyObject *resultobj;
24878     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24879     long arg2 ;
24880     long result;
24881     PyObject * obj0 = 0 ;
24882     PyObject * obj1 = 0 ;
24883     char *kwnames[] = {
24884         (char *) "self",(char *) "item", NULL
24885     };
24886
24887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemData",kwnames,&obj0,&obj1)) goto fail;
24888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24889     if (SWIG_arg_fail(1)) SWIG_fail;
24890     {
24891         arg2 = (long)(SWIG_As_long(obj1));
24892         if (SWIG_arg_fail(2)) SWIG_fail;
24893     }
24894     {
24895         PyThreadState* __tstate = wxPyBeginAllowThreads();
24896         result = (long)((wxPyListCtrl const *)arg1)->GetItemData(arg2);
24897
24898         wxPyEndAllowThreads(__tstate);
24899         if (PyErr_Occurred()) SWIG_fail;
24900     }
24901     {
24902         resultobj = SWIG_From_long((long)(result));
24903     }
24904     return resultobj;
24905     fail:
24906     return NULL;
24907 }
24908
24909
24910 static PyObject *_wrap_ListCtrl_SetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
24911     PyObject *resultobj;
24912     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24913     long arg2 ;
24914     long arg3 ;
24915     bool result;
24916     PyObject * obj0 = 0 ;
24917     PyObject * obj1 = 0 ;
24918     PyObject * obj2 = 0 ;
24919     char *kwnames[] = {
24920         (char *) "self",(char *) "item",(char *) "data", NULL
24921     };
24922
24923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
24924     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24925     if (SWIG_arg_fail(1)) SWIG_fail;
24926     {
24927         arg2 = (long)(SWIG_As_long(obj1));
24928         if (SWIG_arg_fail(2)) SWIG_fail;
24929     }
24930     {
24931         arg3 = (long)(SWIG_As_long(obj2));
24932         if (SWIG_arg_fail(3)) SWIG_fail;
24933     }
24934     {
24935         PyThreadState* __tstate = wxPyBeginAllowThreads();
24936         result = (bool)(arg1)->SetItemData(arg2,arg3);
24937
24938         wxPyEndAllowThreads(__tstate);
24939         if (PyErr_Occurred()) SWIG_fail;
24940     }
24941     {
24942         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943     }
24944     return resultobj;
24945     fail:
24946     return NULL;
24947 }
24948
24949
24950 static PyObject *_wrap_ListCtrl_GetItemPosition(PyObject *, PyObject *args, PyObject *kwargs) {
24951     PyObject *resultobj;
24952     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24953     long arg2 ;
24954     wxPoint result;
24955     PyObject * obj0 = 0 ;
24956     PyObject * obj1 = 0 ;
24957     char *kwnames[] = {
24958         (char *) "self",(char *) "item", NULL
24959     };
24960
24961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemPosition",kwnames,&obj0,&obj1)) goto fail;
24962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
24963     if (SWIG_arg_fail(1)) SWIG_fail;
24964     {
24965         arg2 = (long)(SWIG_As_long(obj1));
24966         if (SWIG_arg_fail(2)) SWIG_fail;
24967     }
24968     {
24969         PyThreadState* __tstate = wxPyBeginAllowThreads();
24970         result = wxPyListCtrl_GetItemPosition(arg1,arg2);
24971
24972         wxPyEndAllowThreads(__tstate);
24973         if (PyErr_Occurred()) SWIG_fail;
24974     }
24975     {
24976         wxPoint * resultptr;
24977         resultptr = new wxPoint((wxPoint &)(result));
24978         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
24979     }
24980     return resultobj;
24981     fail:
24982     return NULL;
24983 }
24984
24985
24986 static PyObject *_wrap_ListCtrl_GetItemRect(PyObject *, PyObject *args, PyObject *kwargs) {
24987     PyObject *resultobj;
24988     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
24989     long arg2 ;
24990     int arg3 = (int) wxLIST_RECT_BOUNDS ;
24991     wxRect result;
24992     PyObject * obj0 = 0 ;
24993     PyObject * obj1 = 0 ;
24994     PyObject * obj2 = 0 ;
24995     char *kwnames[] = {
24996         (char *) "self",(char *) "item",(char *) "code", NULL
24997     };
24998
24999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItemRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25001     if (SWIG_arg_fail(1)) SWIG_fail;
25002     {
25003         arg2 = (long)(SWIG_As_long(obj1));
25004         if (SWIG_arg_fail(2)) SWIG_fail;
25005     }
25006     if (obj2) {
25007         {
25008             arg3 = (int)(SWIG_As_int(obj2));
25009             if (SWIG_arg_fail(3)) SWIG_fail;
25010         }
25011     }
25012     {
25013         PyThreadState* __tstate = wxPyBeginAllowThreads();
25014         result = wxPyListCtrl_GetItemRect(arg1,arg2,arg3);
25015
25016         wxPyEndAllowThreads(__tstate);
25017         if (PyErr_Occurred()) SWIG_fail;
25018     }
25019     {
25020         wxRect * resultptr;
25021         resultptr = new wxRect((wxRect &)(result));
25022         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25023     }
25024     return resultobj;
25025     fail:
25026     return NULL;
25027 }
25028
25029
25030 static PyObject *_wrap_ListCtrl_SetItemPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25031     PyObject *resultobj;
25032     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25033     long arg2 ;
25034     wxPoint *arg3 = 0 ;
25035     bool result;
25036     wxPoint temp3 ;
25037     PyObject * obj0 = 0 ;
25038     PyObject * obj1 = 0 ;
25039     PyObject * obj2 = 0 ;
25040     char *kwnames[] = {
25041         (char *) "self",(char *) "item",(char *) "pos", NULL
25042     };
25043
25044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
25045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25046     if (SWIG_arg_fail(1)) SWIG_fail;
25047     {
25048         arg2 = (long)(SWIG_As_long(obj1));
25049         if (SWIG_arg_fail(2)) SWIG_fail;
25050     }
25051     {
25052         arg3 = &temp3;
25053         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25054     }
25055     {
25056         PyThreadState* __tstate = wxPyBeginAllowThreads();
25057         result = (bool)(arg1)->SetItemPosition(arg2,(wxPoint const &)*arg3);
25058
25059         wxPyEndAllowThreads(__tstate);
25060         if (PyErr_Occurred()) SWIG_fail;
25061     }
25062     {
25063         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064     }
25065     return resultobj;
25066     fail:
25067     return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_ListCtrl_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
25072     PyObject *resultobj;
25073     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25074     int result;
25075     PyObject * obj0 = 0 ;
25076     char *kwnames[] = {
25077         (char *) "self", NULL
25078     };
25079
25080     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetItemCount",kwnames,&obj0)) goto fail;
25081     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25082     if (SWIG_arg_fail(1)) SWIG_fail;
25083     {
25084         PyThreadState* __tstate = wxPyBeginAllowThreads();
25085         result = (int)((wxPyListCtrl const *)arg1)->GetItemCount();
25086
25087         wxPyEndAllowThreads(__tstate);
25088         if (PyErr_Occurred()) SWIG_fail;
25089     }
25090     {
25091         resultobj = SWIG_From_int((int)(result));
25092     }
25093     return resultobj;
25094     fail:
25095     return NULL;
25096 }
25097
25098
25099 static PyObject *_wrap_ListCtrl_GetColumnCount(PyObject *, PyObject *args, PyObject *kwargs) {
25100     PyObject *resultobj;
25101     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25102     int result;
25103     PyObject * obj0 = 0 ;
25104     char *kwnames[] = {
25105         (char *) "self", NULL
25106     };
25107
25108     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetColumnCount",kwnames,&obj0)) goto fail;
25109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25110     if (SWIG_arg_fail(1)) SWIG_fail;
25111     {
25112         PyThreadState* __tstate = wxPyBeginAllowThreads();
25113         result = (int)((wxPyListCtrl const *)arg1)->GetColumnCount();
25114
25115         wxPyEndAllowThreads(__tstate);
25116         if (PyErr_Occurred()) SWIG_fail;
25117     }
25118     {
25119         resultobj = SWIG_From_int((int)(result));
25120     }
25121     return resultobj;
25122     fail:
25123     return NULL;
25124 }
25125
25126
25127 static PyObject *_wrap_ListCtrl_GetItemSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
25128     PyObject *resultobj;
25129     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25130     wxSize result;
25131     PyObject * obj0 = 0 ;
25132     char *kwnames[] = {
25133         (char *) "self", NULL
25134     };
25135
25136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetItemSpacing",kwnames,&obj0)) goto fail;
25137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25138     if (SWIG_arg_fail(1)) SWIG_fail;
25139     {
25140         PyThreadState* __tstate = wxPyBeginAllowThreads();
25141         result = ((wxPyListCtrl const *)arg1)->GetItemSpacing();
25142
25143         wxPyEndAllowThreads(__tstate);
25144         if (PyErr_Occurred()) SWIG_fail;
25145     }
25146     {
25147         wxSize * resultptr;
25148         resultptr = new wxSize((wxSize &)(result));
25149         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25150     }
25151     return resultobj;
25152     fail:
25153     return NULL;
25154 }
25155
25156
25157 static PyObject *_wrap_ListCtrl_GetSelectedItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
25158     PyObject *resultobj;
25159     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25160     int result;
25161     PyObject * obj0 = 0 ;
25162     char *kwnames[] = {
25163         (char *) "self", NULL
25164     };
25165
25166     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetSelectedItemCount",kwnames,&obj0)) goto fail;
25167     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25168     if (SWIG_arg_fail(1)) SWIG_fail;
25169     {
25170         PyThreadState* __tstate = wxPyBeginAllowThreads();
25171         result = (int)((wxPyListCtrl const *)arg1)->GetSelectedItemCount();
25172
25173         wxPyEndAllowThreads(__tstate);
25174         if (PyErr_Occurred()) SWIG_fail;
25175     }
25176     {
25177         resultobj = SWIG_From_int((int)(result));
25178     }
25179     return resultobj;
25180     fail:
25181     return NULL;
25182 }
25183
25184
25185 static PyObject *_wrap_ListCtrl_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
25186     PyObject *resultobj;
25187     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25188     wxColour result;
25189     PyObject * obj0 = 0 ;
25190     char *kwnames[] = {
25191         (char *) "self", NULL
25192     };
25193
25194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetTextColour",kwnames,&obj0)) goto fail;
25195     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25196     if (SWIG_arg_fail(1)) SWIG_fail;
25197     {
25198         PyThreadState* __tstate = wxPyBeginAllowThreads();
25199         result = ((wxPyListCtrl const *)arg1)->GetTextColour();
25200
25201         wxPyEndAllowThreads(__tstate);
25202         if (PyErr_Occurred()) SWIG_fail;
25203     }
25204     {
25205         wxColour * resultptr;
25206         resultptr = new wxColour((wxColour &)(result));
25207         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
25208     }
25209     return resultobj;
25210     fail:
25211     return NULL;
25212 }
25213
25214
25215 static PyObject *_wrap_ListCtrl_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
25216     PyObject *resultobj;
25217     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25218     wxColour *arg2 = 0 ;
25219     wxColour temp2 ;
25220     PyObject * obj0 = 0 ;
25221     PyObject * obj1 = 0 ;
25222     char *kwnames[] = {
25223         (char *) "self",(char *) "col", NULL
25224     };
25225
25226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
25227     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25228     if (SWIG_arg_fail(1)) SWIG_fail;
25229     {
25230         arg2 = &temp2;
25231         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25232     }
25233     {
25234         PyThreadState* __tstate = wxPyBeginAllowThreads();
25235         (arg1)->SetTextColour((wxColour const &)*arg2);
25236
25237         wxPyEndAllowThreads(__tstate);
25238         if (PyErr_Occurred()) SWIG_fail;
25239     }
25240     Py_INCREF(Py_None); resultobj = Py_None;
25241     return resultobj;
25242     fail:
25243     return NULL;
25244 }
25245
25246
25247 static PyObject *_wrap_ListCtrl_GetTopItem(PyObject *, PyObject *args, PyObject *kwargs) {
25248     PyObject *resultobj;
25249     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25250     long result;
25251     PyObject * obj0 = 0 ;
25252     char *kwnames[] = {
25253         (char *) "self", NULL
25254     };
25255
25256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetTopItem",kwnames,&obj0)) goto fail;
25257     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25258     if (SWIG_arg_fail(1)) SWIG_fail;
25259     {
25260         PyThreadState* __tstate = wxPyBeginAllowThreads();
25261         result = (long)((wxPyListCtrl const *)arg1)->GetTopItem();
25262
25263         wxPyEndAllowThreads(__tstate);
25264         if (PyErr_Occurred()) SWIG_fail;
25265     }
25266     {
25267         resultobj = SWIG_From_long((long)(result));
25268     }
25269     return resultobj;
25270     fail:
25271     return NULL;
25272 }
25273
25274
25275 static PyObject *_wrap_ListCtrl_SetSingleStyle(PyObject *, PyObject *args, PyObject *kwargs) {
25276     PyObject *resultobj;
25277     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25278     long arg2 ;
25279     bool arg3 = (bool) true ;
25280     PyObject * obj0 = 0 ;
25281     PyObject * obj1 = 0 ;
25282     PyObject * obj2 = 0 ;
25283     char *kwnames[] = {
25284         (char *) "self",(char *) "style",(char *) "add", NULL
25285     };
25286
25287     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_SetSingleStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
25288     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25289     if (SWIG_arg_fail(1)) SWIG_fail;
25290     {
25291         arg2 = (long)(SWIG_As_long(obj1));
25292         if (SWIG_arg_fail(2)) SWIG_fail;
25293     }
25294     if (obj2) {
25295         {
25296             arg3 = (bool)(SWIG_As_bool(obj2));
25297             if (SWIG_arg_fail(3)) SWIG_fail;
25298         }
25299     }
25300     {
25301         PyThreadState* __tstate = wxPyBeginAllowThreads();
25302         (arg1)->SetSingleStyle(arg2,arg3);
25303
25304         wxPyEndAllowThreads(__tstate);
25305         if (PyErr_Occurred()) SWIG_fail;
25306     }
25307     Py_INCREF(Py_None); resultobj = Py_None;
25308     return resultobj;
25309     fail:
25310     return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_ListCtrl_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
25315     PyObject *resultobj;
25316     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25317     long arg2 ;
25318     PyObject * obj0 = 0 ;
25319     PyObject * obj1 = 0 ;
25320     char *kwnames[] = {
25321         (char *) "self",(char *) "style", NULL
25322     };
25323
25324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
25325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25326     if (SWIG_arg_fail(1)) SWIG_fail;
25327     {
25328         arg2 = (long)(SWIG_As_long(obj1));
25329         if (SWIG_arg_fail(2)) SWIG_fail;
25330     }
25331     {
25332         PyThreadState* __tstate = wxPyBeginAllowThreads();
25333         (arg1)->SetWindowStyleFlag(arg2);
25334
25335         wxPyEndAllowThreads(__tstate);
25336         if (PyErr_Occurred()) SWIG_fail;
25337     }
25338     Py_INCREF(Py_None); resultobj = Py_None;
25339     return resultobj;
25340     fail:
25341     return NULL;
25342 }
25343
25344
25345 static PyObject *_wrap_ListCtrl_GetNextItem(PyObject *, PyObject *args, PyObject *kwargs) {
25346     PyObject *resultobj;
25347     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25348     long arg2 ;
25349     int arg3 = (int) wxLIST_NEXT_ALL ;
25350     int arg4 = (int) wxLIST_STATE_DONTCARE ;
25351     long result;
25352     PyObject * obj0 = 0 ;
25353     PyObject * obj1 = 0 ;
25354     PyObject * obj2 = 0 ;
25355     PyObject * obj3 = 0 ;
25356     char *kwnames[] = {
25357         (char *) "self",(char *) "item",(char *) "geometry",(char *) "state", NULL
25358     };
25359
25360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:ListCtrl_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25362     if (SWIG_arg_fail(1)) SWIG_fail;
25363     {
25364         arg2 = (long)(SWIG_As_long(obj1));
25365         if (SWIG_arg_fail(2)) SWIG_fail;
25366     }
25367     if (obj2) {
25368         {
25369             arg3 = (int)(SWIG_As_int(obj2));
25370             if (SWIG_arg_fail(3)) SWIG_fail;
25371         }
25372     }
25373     if (obj3) {
25374         {
25375             arg4 = (int)(SWIG_As_int(obj3));
25376             if (SWIG_arg_fail(4)) SWIG_fail;
25377         }
25378     }
25379     {
25380         PyThreadState* __tstate = wxPyBeginAllowThreads();
25381         result = (long)((wxPyListCtrl const *)arg1)->GetNextItem(arg2,arg3,arg4);
25382
25383         wxPyEndAllowThreads(__tstate);
25384         if (PyErr_Occurred()) SWIG_fail;
25385     }
25386     {
25387         resultobj = SWIG_From_long((long)(result));
25388     }
25389     return resultobj;
25390     fail:
25391     return NULL;
25392 }
25393
25394
25395 static PyObject *_wrap_ListCtrl_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25396     PyObject *resultobj;
25397     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25398     int arg2 ;
25399     wxImageList *result;
25400     PyObject * obj0 = 0 ;
25401     PyObject * obj1 = 0 ;
25402     char *kwnames[] = {
25403         (char *) "self",(char *) "which", NULL
25404     };
25405
25406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetImageList",kwnames,&obj0,&obj1)) goto fail;
25407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25408     if (SWIG_arg_fail(1)) SWIG_fail;
25409     {
25410         arg2 = (int)(SWIG_As_int(obj1));
25411         if (SWIG_arg_fail(2)) SWIG_fail;
25412     }
25413     {
25414         PyThreadState* __tstate = wxPyBeginAllowThreads();
25415         result = (wxImageList *)((wxPyListCtrl const *)arg1)->GetImageList(arg2);
25416
25417         wxPyEndAllowThreads(__tstate);
25418         if (PyErr_Occurred()) SWIG_fail;
25419     }
25420     {
25421         resultobj = wxPyMake_wxObject(result, 0);
25422     }
25423     return resultobj;
25424     fail:
25425     return NULL;
25426 }
25427
25428
25429 static PyObject *_wrap_ListCtrl_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25430     PyObject *resultobj;
25431     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25432     wxImageList *arg2 = (wxImageList *) 0 ;
25433     int arg3 ;
25434     PyObject * obj0 = 0 ;
25435     PyObject * obj1 = 0 ;
25436     PyObject * obj2 = 0 ;
25437     char *kwnames[] = {
25438         (char *) "self",(char *) "imageList",(char *) "which", NULL
25439     };
25440
25441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetImageList",kwnames,&obj0,&obj1,&obj2)) goto fail;
25442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25443     if (SWIG_arg_fail(1)) SWIG_fail;
25444     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
25445     if (SWIG_arg_fail(2)) SWIG_fail;
25446     {
25447         arg3 = (int)(SWIG_As_int(obj2));
25448         if (SWIG_arg_fail(3)) SWIG_fail;
25449     }
25450     {
25451         PyThreadState* __tstate = wxPyBeginAllowThreads();
25452         (arg1)->SetImageList(arg2,arg3);
25453
25454         wxPyEndAllowThreads(__tstate);
25455         if (PyErr_Occurred()) SWIG_fail;
25456     }
25457     Py_INCREF(Py_None); resultobj = Py_None;
25458     return resultobj;
25459     fail:
25460     return NULL;
25461 }
25462
25463
25464 static PyObject *_wrap_ListCtrl_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
25465     PyObject *resultobj;
25466     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25467     wxImageList *arg2 = (wxImageList *) 0 ;
25468     int arg3 ;
25469     PyObject * obj0 = 0 ;
25470     PyObject * obj1 = 0 ;
25471     PyObject * obj2 = 0 ;
25472     char *kwnames[] = {
25473         (char *) "self",(char *) "imageList",(char *) "which", NULL
25474     };
25475
25476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_AssignImageList",kwnames,&obj0,&obj1,&obj2)) goto fail;
25477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25478     if (SWIG_arg_fail(1)) SWIG_fail;
25479     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25480     if (SWIG_arg_fail(2)) SWIG_fail;
25481     {
25482         arg3 = (int)(SWIG_As_int(obj2));
25483         if (SWIG_arg_fail(3)) SWIG_fail;
25484     }
25485     {
25486         PyThreadState* __tstate = wxPyBeginAllowThreads();
25487         (arg1)->AssignImageList(arg2,arg3);
25488
25489         wxPyEndAllowThreads(__tstate);
25490         if (PyErr_Occurred()) SWIG_fail;
25491     }
25492     Py_INCREF(Py_None); resultobj = Py_None;
25493     return resultobj;
25494     fail:
25495     return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_ListCtrl_InReportView(PyObject *, PyObject *args, PyObject *kwargs) {
25500     PyObject *resultobj;
25501     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25502     bool result;
25503     PyObject * obj0 = 0 ;
25504     char *kwnames[] = {
25505         (char *) "self", NULL
25506     };
25507
25508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_InReportView",kwnames,&obj0)) goto fail;
25509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25510     if (SWIG_arg_fail(1)) SWIG_fail;
25511     {
25512         PyThreadState* __tstate = wxPyBeginAllowThreads();
25513         result = (bool)((wxPyListCtrl const *)arg1)->InReportView();
25514
25515         wxPyEndAllowThreads(__tstate);
25516         if (PyErr_Occurred()) SWIG_fail;
25517     }
25518     {
25519         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25520     }
25521     return resultobj;
25522     fail:
25523     return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_ListCtrl_IsVirtual(PyObject *, PyObject *args, PyObject *kwargs) {
25528     PyObject *resultobj;
25529     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25530     bool result;
25531     PyObject * obj0 = 0 ;
25532     char *kwnames[] = {
25533         (char *) "self", NULL
25534     };
25535
25536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_IsVirtual",kwnames,&obj0)) goto fail;
25537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25538     if (SWIG_arg_fail(1)) SWIG_fail;
25539     {
25540         PyThreadState* __tstate = wxPyBeginAllowThreads();
25541         result = (bool)((wxPyListCtrl const *)arg1)->IsVirtual();
25542
25543         wxPyEndAllowThreads(__tstate);
25544         if (PyErr_Occurred()) SWIG_fail;
25545     }
25546     {
25547         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25548     }
25549     return resultobj;
25550     fail:
25551     return NULL;
25552 }
25553
25554
25555 static PyObject *_wrap_ListCtrl_RefreshItem(PyObject *, PyObject *args, PyObject *kwargs) {
25556     PyObject *resultobj;
25557     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25558     long arg2 ;
25559     PyObject * obj0 = 0 ;
25560     PyObject * obj1 = 0 ;
25561     char *kwnames[] = {
25562         (char *) "self",(char *) "item", NULL
25563     };
25564
25565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_RefreshItem",kwnames,&obj0,&obj1)) goto fail;
25566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25567     if (SWIG_arg_fail(1)) SWIG_fail;
25568     {
25569         arg2 = (long)(SWIG_As_long(obj1));
25570         if (SWIG_arg_fail(2)) SWIG_fail;
25571     }
25572     {
25573         PyThreadState* __tstate = wxPyBeginAllowThreads();
25574         (arg1)->RefreshItem(arg2);
25575
25576         wxPyEndAllowThreads(__tstate);
25577         if (PyErr_Occurred()) SWIG_fail;
25578     }
25579     Py_INCREF(Py_None); resultobj = Py_None;
25580     return resultobj;
25581     fail:
25582     return NULL;
25583 }
25584
25585
25586 static PyObject *_wrap_ListCtrl_RefreshItems(PyObject *, PyObject *args, PyObject *kwargs) {
25587     PyObject *resultobj;
25588     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25589     long arg2 ;
25590     long arg3 ;
25591     PyObject * obj0 = 0 ;
25592     PyObject * obj1 = 0 ;
25593     PyObject * obj2 = 0 ;
25594     char *kwnames[] = {
25595         (char *) "self",(char *) "itemFrom",(char *) "itemTo", NULL
25596     };
25597
25598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_RefreshItems",kwnames,&obj0,&obj1,&obj2)) goto fail;
25599     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25600     if (SWIG_arg_fail(1)) SWIG_fail;
25601     {
25602         arg2 = (long)(SWIG_As_long(obj1));
25603         if (SWIG_arg_fail(2)) SWIG_fail;
25604     }
25605     {
25606         arg3 = (long)(SWIG_As_long(obj2));
25607         if (SWIG_arg_fail(3)) SWIG_fail;
25608     }
25609     {
25610         PyThreadState* __tstate = wxPyBeginAllowThreads();
25611         (arg1)->RefreshItems(arg2,arg3);
25612
25613         wxPyEndAllowThreads(__tstate);
25614         if (PyErr_Occurred()) SWIG_fail;
25615     }
25616     Py_INCREF(Py_None); resultobj = Py_None;
25617     return resultobj;
25618     fail:
25619     return NULL;
25620 }
25621
25622
25623 static PyObject *_wrap_ListCtrl_Arrange(PyObject *, PyObject *args, PyObject *kwargs) {
25624     PyObject *resultobj;
25625     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25626     int arg2 = (int) wxLIST_ALIGN_DEFAULT ;
25627     bool result;
25628     PyObject * obj0 = 0 ;
25629     PyObject * obj1 = 0 ;
25630     char *kwnames[] = {
25631         (char *) "self",(char *) "flag", NULL
25632     };
25633
25634     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListCtrl_Arrange",kwnames,&obj0,&obj1)) goto fail;
25635     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25636     if (SWIG_arg_fail(1)) SWIG_fail;
25637     if (obj1) {
25638         {
25639             arg2 = (int)(SWIG_As_int(obj1));
25640             if (SWIG_arg_fail(2)) SWIG_fail;
25641         }
25642     }
25643     {
25644         PyThreadState* __tstate = wxPyBeginAllowThreads();
25645         result = (bool)(arg1)->Arrange(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_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
25660     PyObject *resultobj;
25661     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25662     long arg2 ;
25663     bool result;
25664     PyObject * obj0 = 0 ;
25665     PyObject * obj1 = 0 ;
25666     char *kwnames[] = {
25667         (char *) "self",(char *) "item", NULL
25668     };
25669
25670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
25671     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25672     if (SWIG_arg_fail(1)) SWIG_fail;
25673     {
25674         arg2 = (long)(SWIG_As_long(obj1));
25675         if (SWIG_arg_fail(2)) SWIG_fail;
25676     }
25677     {
25678         PyThreadState* __tstate = wxPyBeginAllowThreads();
25679         result = (bool)(arg1)->DeleteItem(arg2);
25680
25681         wxPyEndAllowThreads(__tstate);
25682         if (PyErr_Occurred()) SWIG_fail;
25683     }
25684     {
25685         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25686     }
25687     return resultobj;
25688     fail:
25689     return NULL;
25690 }
25691
25692
25693 static PyObject *_wrap_ListCtrl_DeleteAllItems(PyObject *, PyObject *args, PyObject *kwargs) {
25694     PyObject *resultobj;
25695     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25696     bool result;
25697     PyObject * obj0 = 0 ;
25698     char *kwnames[] = {
25699         (char *) "self", NULL
25700     };
25701
25702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_DeleteAllItems",kwnames,&obj0)) goto fail;
25703     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25704     if (SWIG_arg_fail(1)) SWIG_fail;
25705     {
25706         PyThreadState* __tstate = wxPyBeginAllowThreads();
25707         result = (bool)(arg1)->DeleteAllItems();
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_DeleteColumn(PyObject *, PyObject *args, PyObject *kwargs) {
25722     PyObject *resultobj;
25723     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25724     int arg2 ;
25725     bool result;
25726     PyObject * obj0 = 0 ;
25727     PyObject * obj1 = 0 ;
25728     char *kwnames[] = {
25729         (char *) "self",(char *) "col", NULL
25730     };
25731
25732     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteColumn",kwnames,&obj0,&obj1)) goto fail;
25733     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25734     if (SWIG_arg_fail(1)) SWIG_fail;
25735     {
25736         arg2 = (int)(SWIG_As_int(obj1));
25737         if (SWIG_arg_fail(2)) SWIG_fail;
25738     }
25739     {
25740         PyThreadState* __tstate = wxPyBeginAllowThreads();
25741         result = (bool)(arg1)->DeleteColumn(arg2);
25742
25743         wxPyEndAllowThreads(__tstate);
25744         if (PyErr_Occurred()) SWIG_fail;
25745     }
25746     {
25747         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25748     }
25749     return resultobj;
25750     fail:
25751     return NULL;
25752 }
25753
25754
25755 static PyObject *_wrap_ListCtrl_DeleteAllColumns(PyObject *, PyObject *args, PyObject *kwargs) {
25756     PyObject *resultobj;
25757     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25758     bool result;
25759     PyObject * obj0 = 0 ;
25760     char *kwnames[] = {
25761         (char *) "self", NULL
25762     };
25763
25764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_DeleteAllColumns",kwnames,&obj0)) goto fail;
25765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25766     if (SWIG_arg_fail(1)) SWIG_fail;
25767     {
25768         PyThreadState* __tstate = wxPyBeginAllowThreads();
25769         result = (bool)(arg1)->DeleteAllColumns();
25770
25771         wxPyEndAllowThreads(__tstate);
25772         if (PyErr_Occurred()) SWIG_fail;
25773     }
25774     {
25775         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25776     }
25777     return resultobj;
25778     fail:
25779     return NULL;
25780 }
25781
25782
25783 static PyObject *_wrap_ListCtrl_ClearAll(PyObject *, PyObject *args, PyObject *kwargs) {
25784     PyObject *resultobj;
25785     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25786     PyObject * obj0 = 0 ;
25787     char *kwnames[] = {
25788         (char *) "self", NULL
25789     };
25790
25791     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_ClearAll",kwnames,&obj0)) goto fail;
25792     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25793     if (SWIG_arg_fail(1)) SWIG_fail;
25794     {
25795         PyThreadState* __tstate = wxPyBeginAllowThreads();
25796         (arg1)->ClearAll();
25797
25798         wxPyEndAllowThreads(__tstate);
25799         if (PyErr_Occurred()) SWIG_fail;
25800     }
25801     Py_INCREF(Py_None); resultobj = Py_None;
25802     return resultobj;
25803     fail:
25804     return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_ListCtrl_EditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25809     PyObject *resultobj;
25810     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25811     long arg2 ;
25812     wxTextCtrl *result;
25813     PyObject * obj0 = 0 ;
25814     PyObject * obj1 = 0 ;
25815     char *kwnames[] = {
25816         (char *) "self",(char *) "item", NULL
25817     };
25818
25819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EditLabel",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 = (long)(SWIG_As_long(obj1));
25824         if (SWIG_arg_fail(2)) SWIG_fail;
25825     }
25826     {
25827         PyThreadState* __tstate = wxPyBeginAllowThreads();
25828         result = (wxTextCtrl *)(arg1)->EditLabel(arg2);
25829
25830         wxPyEndAllowThreads(__tstate);
25831         if (PyErr_Occurred()) SWIG_fail;
25832     }
25833     {
25834         resultobj = wxPyMake_wxObject(result, 0);
25835     }
25836     return resultobj;
25837     fail:
25838     return NULL;
25839 }
25840
25841
25842 static PyObject *_wrap_ListCtrl_EndEditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25843     PyObject *resultobj;
25844     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25845     bool arg2 ;
25846     bool result;
25847     PyObject * obj0 = 0 ;
25848     PyObject * obj1 = 0 ;
25849     char *kwnames[] = {
25850         (char *) "self",(char *) "cancel", NULL
25851     };
25852
25853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EndEditLabel",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 = (bool)(SWIG_As_bool(obj1));
25858         if (SWIG_arg_fail(2)) SWIG_fail;
25859     }
25860     {
25861         PyThreadState* __tstate = wxPyBeginAllowThreads();
25862         result = (bool)(arg1)->EndEditLabel(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_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
25877     PyObject *resultobj;
25878     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25879     long arg2 ;
25880     bool result;
25881     PyObject * obj0 = 0 ;
25882     PyObject * obj1 = 0 ;
25883     char *kwnames[] = {
25884         (char *) "self",(char *) "item", NULL
25885     };
25886
25887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
25888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25889     if (SWIG_arg_fail(1)) SWIG_fail;
25890     {
25891         arg2 = (long)(SWIG_As_long(obj1));
25892         if (SWIG_arg_fail(2)) SWIG_fail;
25893     }
25894     {
25895         PyThreadState* __tstate = wxPyBeginAllowThreads();
25896         result = (bool)(arg1)->EnsureVisible(arg2);
25897
25898         wxPyEndAllowThreads(__tstate);
25899         if (PyErr_Occurred()) SWIG_fail;
25900     }
25901     {
25902         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25903     }
25904     return resultobj;
25905     fail:
25906     return NULL;
25907 }
25908
25909
25910 static PyObject *_wrap_ListCtrl_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
25911     PyObject *resultobj;
25912     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25913     long arg2 ;
25914     wxString *arg3 = 0 ;
25915     bool arg4 = (bool) false ;
25916     long result;
25917     bool temp3 = false ;
25918     PyObject * obj0 = 0 ;
25919     PyObject * obj1 = 0 ;
25920     PyObject * obj2 = 0 ;
25921     PyObject * obj3 = 0 ;
25922     char *kwnames[] = {
25923         (char *) "self",(char *) "start",(char *) "str",(char *) "partial", NULL
25924     };
25925
25926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_FindItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25928     if (SWIG_arg_fail(1)) SWIG_fail;
25929     {
25930         arg2 = (long)(SWIG_As_long(obj1));
25931         if (SWIG_arg_fail(2)) SWIG_fail;
25932     }
25933     {
25934         arg3 = wxString_in_helper(obj2);
25935         if (arg3 == NULL) SWIG_fail;
25936         temp3 = true;
25937     }
25938     if (obj3) {
25939         {
25940             arg4 = (bool)(SWIG_As_bool(obj3));
25941             if (SWIG_arg_fail(4)) SWIG_fail;
25942         }
25943     }
25944     {
25945         PyThreadState* __tstate = wxPyBeginAllowThreads();
25946         result = (long)(arg1)->FindItem(arg2,(wxString const &)*arg3,arg4);
25947
25948         wxPyEndAllowThreads(__tstate);
25949         if (PyErr_Occurred()) SWIG_fail;
25950     }
25951     {
25952         resultobj = SWIG_From_long((long)(result));
25953     }
25954     {
25955         if (temp3)
25956         delete arg3;
25957     }
25958     return resultobj;
25959     fail:
25960     {
25961         if (temp3)
25962         delete arg3;
25963     }
25964     return NULL;
25965 }
25966
25967
25968 static PyObject *_wrap_ListCtrl_FindItemData(PyObject *, PyObject *args, PyObject *kwargs) {
25969     PyObject *resultobj;
25970     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
25971     long arg2 ;
25972     long arg3 ;
25973     long result;
25974     PyObject * obj0 = 0 ;
25975     PyObject * obj1 = 0 ;
25976     PyObject * obj2 = 0 ;
25977     char *kwnames[] = {
25978         (char *) "self",(char *) "start",(char *) "data", NULL
25979     };
25980
25981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_FindItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
25982     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
25983     if (SWIG_arg_fail(1)) SWIG_fail;
25984     {
25985         arg2 = (long)(SWIG_As_long(obj1));
25986         if (SWIG_arg_fail(2)) SWIG_fail;
25987     }
25988     {
25989         arg3 = (long)(SWIG_As_long(obj2));
25990         if (SWIG_arg_fail(3)) SWIG_fail;
25991     }
25992     {
25993         PyThreadState* __tstate = wxPyBeginAllowThreads();
25994         result = (long)(arg1)->FindItem(arg2,arg3);
25995
25996         wxPyEndAllowThreads(__tstate);
25997         if (PyErr_Occurred()) SWIG_fail;
25998     }
25999     {
26000         resultobj = SWIG_From_long((long)(result));
26001     }
26002     return resultobj;
26003     fail:
26004     return NULL;
26005 }
26006
26007
26008 static PyObject *_wrap_ListCtrl_FindItemAtPos(PyObject *, PyObject *args, PyObject *kwargs) {
26009     PyObject *resultobj;
26010     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26011     long arg2 ;
26012     wxPoint *arg3 = 0 ;
26013     int arg4 ;
26014     long result;
26015     wxPoint temp3 ;
26016     PyObject * obj0 = 0 ;
26017     PyObject * obj1 = 0 ;
26018     PyObject * obj2 = 0 ;
26019     PyObject * obj3 = 0 ;
26020     char *kwnames[] = {
26021         (char *) "self",(char *) "start",(char *) "pt",(char *) "direction", NULL
26022     };
26023
26024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_FindItemAtPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26026     if (SWIG_arg_fail(1)) SWIG_fail;
26027     {
26028         arg2 = (long)(SWIG_As_long(obj1));
26029         if (SWIG_arg_fail(2)) SWIG_fail;
26030     }
26031     {
26032         arg3 = &temp3;
26033         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26034     }
26035     {
26036         arg4 = (int)(SWIG_As_int(obj3));
26037         if (SWIG_arg_fail(4)) SWIG_fail;
26038     }
26039     {
26040         PyThreadState* __tstate = wxPyBeginAllowThreads();
26041         result = (long)(arg1)->FindItem(arg2,(wxPoint const &)*arg3,arg4);
26042
26043         wxPyEndAllowThreads(__tstate);
26044         if (PyErr_Occurred()) SWIG_fail;
26045     }
26046     {
26047         resultobj = SWIG_From_long((long)(result));
26048     }
26049     return resultobj;
26050     fail:
26051     return NULL;
26052 }
26053
26054
26055 static PyObject *_wrap_ListCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
26056     PyObject *resultobj;
26057     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26058     wxPoint *arg2 = 0 ;
26059     int *arg3 = 0 ;
26060     long result;
26061     wxPoint temp2 ;
26062     int temp3 ;
26063     int res3 = 0 ;
26064     PyObject * obj0 = 0 ;
26065     PyObject * obj1 = 0 ;
26066     char *kwnames[] = {
26067         (char *) "self",(char *) "point", NULL
26068     };
26069
26070     arg3 = &temp3; res3 = SWIG_NEWOBJ;
26071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
26072     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26073     if (SWIG_arg_fail(1)) SWIG_fail;
26074     {
26075         arg2 = &temp2;
26076         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26077     }
26078     {
26079         PyThreadState* __tstate = wxPyBeginAllowThreads();
26080         result = (long)(arg1)->HitTest((wxPoint const &)*arg2,*arg3);
26081
26082         wxPyEndAllowThreads(__tstate);
26083         if (PyErr_Occurred()) SWIG_fail;
26084     }
26085     {
26086         resultobj = SWIG_From_long((long)(result));
26087     }
26088     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26089     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26090     return resultobj;
26091     fail:
26092     return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_ListCtrl_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
26097     PyObject *resultobj;
26098     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26099     wxListItem *arg2 = 0 ;
26100     long result;
26101     PyObject * obj0 = 0 ;
26102     PyObject * obj1 = 0 ;
26103     char *kwnames[] = {
26104         (char *) "self",(char *) "info", NULL
26105     };
26106
26107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_InsertItem",kwnames,&obj0,&obj1)) goto fail;
26108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26109     if (SWIG_arg_fail(1)) SWIG_fail;
26110     {
26111         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
26112         if (SWIG_arg_fail(2)) SWIG_fail;
26113         if (arg2 == NULL) {
26114             SWIG_null_ref("wxListItem");
26115         }
26116         if (SWIG_arg_fail(2)) SWIG_fail;
26117     }
26118     {
26119         PyThreadState* __tstate = wxPyBeginAllowThreads();
26120         result = (long)(arg1)->InsertItem(*arg2);
26121
26122         wxPyEndAllowThreads(__tstate);
26123         if (PyErr_Occurred()) SWIG_fail;
26124     }
26125     {
26126         resultobj = SWIG_From_long((long)(result));
26127     }
26128     return resultobj;
26129     fail:
26130     return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_ListCtrl_InsertStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
26135     PyObject *resultobj;
26136     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26137     long arg2 ;
26138     wxString *arg3 = 0 ;
26139     long result;
26140     bool temp3 = false ;
26141     PyObject * obj0 = 0 ;
26142     PyObject * obj1 = 0 ;
26143     PyObject * obj2 = 0 ;
26144     char *kwnames[] = {
26145         (char *) "self",(char *) "index",(char *) "label", NULL
26146     };
26147
26148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertStringItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
26149     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26150     if (SWIG_arg_fail(1)) SWIG_fail;
26151     {
26152         arg2 = (long)(SWIG_As_long(obj1));
26153         if (SWIG_arg_fail(2)) SWIG_fail;
26154     }
26155     {
26156         arg3 = wxString_in_helper(obj2);
26157         if (arg3 == NULL) SWIG_fail;
26158         temp3 = true;
26159     }
26160     {
26161         PyThreadState* __tstate = wxPyBeginAllowThreads();
26162         result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3);
26163
26164         wxPyEndAllowThreads(__tstate);
26165         if (PyErr_Occurred()) SWIG_fail;
26166     }
26167     {
26168         resultobj = SWIG_From_long((long)(result));
26169     }
26170     {
26171         if (temp3)
26172         delete arg3;
26173     }
26174     return resultobj;
26175     fail:
26176     {
26177         if (temp3)
26178         delete arg3;
26179     }
26180     return NULL;
26181 }
26182
26183
26184 static PyObject *_wrap_ListCtrl_InsertImageItem(PyObject *, PyObject *args, PyObject *kwargs) {
26185     PyObject *resultobj;
26186     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26187     long arg2 ;
26188     int arg3 ;
26189     long result;
26190     PyObject * obj0 = 0 ;
26191     PyObject * obj1 = 0 ;
26192     PyObject * obj2 = 0 ;
26193     char *kwnames[] = {
26194         (char *) "self",(char *) "index",(char *) "imageIndex", NULL
26195     };
26196
26197     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertImageItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
26198     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26199     if (SWIG_arg_fail(1)) SWIG_fail;
26200     {
26201         arg2 = (long)(SWIG_As_long(obj1));
26202         if (SWIG_arg_fail(2)) SWIG_fail;
26203     }
26204     {
26205         arg3 = (int)(SWIG_As_int(obj2));
26206         if (SWIG_arg_fail(3)) SWIG_fail;
26207     }
26208     {
26209         PyThreadState* __tstate = wxPyBeginAllowThreads();
26210         result = (long)(arg1)->InsertItem(arg2,arg3);
26211
26212         wxPyEndAllowThreads(__tstate);
26213         if (PyErr_Occurred()) SWIG_fail;
26214     }
26215     {
26216         resultobj = SWIG_From_long((long)(result));
26217     }
26218     return resultobj;
26219     fail:
26220     return NULL;
26221 }
26222
26223
26224 static PyObject *_wrap_ListCtrl_InsertImageStringItem(PyObject *, PyObject *args, PyObject *kwargs) {
26225     PyObject *resultobj;
26226     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26227     long arg2 ;
26228     wxString *arg3 = 0 ;
26229     int arg4 ;
26230     long result;
26231     bool temp3 = false ;
26232     PyObject * obj0 = 0 ;
26233     PyObject * obj1 = 0 ;
26234     PyObject * obj2 = 0 ;
26235     PyObject * obj3 = 0 ;
26236     char *kwnames[] = {
26237         (char *) "self",(char *) "index",(char *) "label",(char *) "imageIndex", NULL
26238     };
26239
26240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_InsertImageStringItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26242     if (SWIG_arg_fail(1)) SWIG_fail;
26243     {
26244         arg2 = (long)(SWIG_As_long(obj1));
26245         if (SWIG_arg_fail(2)) SWIG_fail;
26246     }
26247     {
26248         arg3 = wxString_in_helper(obj2);
26249         if (arg3 == NULL) SWIG_fail;
26250         temp3 = true;
26251     }
26252     {
26253         arg4 = (int)(SWIG_As_int(obj3));
26254         if (SWIG_arg_fail(4)) SWIG_fail;
26255     }
26256     {
26257         PyThreadState* __tstate = wxPyBeginAllowThreads();
26258         result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3,arg4);
26259
26260         wxPyEndAllowThreads(__tstate);
26261         if (PyErr_Occurred()) SWIG_fail;
26262     }
26263     {
26264         resultobj = SWIG_From_long((long)(result));
26265     }
26266     {
26267         if (temp3)
26268         delete arg3;
26269     }
26270     return resultobj;
26271     fail:
26272     {
26273         if (temp3)
26274         delete arg3;
26275     }
26276     return NULL;
26277 }
26278
26279
26280 static PyObject *_wrap_ListCtrl_InsertColumnInfo(PyObject *, PyObject *args, PyObject *kwargs) {
26281     PyObject *resultobj;
26282     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26283     long arg2 ;
26284     wxListItem *arg3 = 0 ;
26285     long result;
26286     PyObject * obj0 = 0 ;
26287     PyObject * obj1 = 0 ;
26288     PyObject * obj2 = 0 ;
26289     char *kwnames[] = {
26290         (char *) "self",(char *) "col",(char *) "info", NULL
26291     };
26292
26293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertColumnInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
26294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26295     if (SWIG_arg_fail(1)) SWIG_fail;
26296     {
26297         arg2 = (long)(SWIG_As_long(obj1));
26298         if (SWIG_arg_fail(2)) SWIG_fail;
26299     }
26300     {
26301         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxListItem, SWIG_POINTER_EXCEPTION | 0);
26302         if (SWIG_arg_fail(3)) SWIG_fail;
26303         if (arg3 == NULL) {
26304             SWIG_null_ref("wxListItem");
26305         }
26306         if (SWIG_arg_fail(3)) SWIG_fail;
26307     }
26308     {
26309         PyThreadState* __tstate = wxPyBeginAllowThreads();
26310         result = (long)(arg1)->InsertColumn(arg2,*arg3);
26311
26312         wxPyEndAllowThreads(__tstate);
26313         if (PyErr_Occurred()) SWIG_fail;
26314     }
26315     {
26316         resultobj = SWIG_From_long((long)(result));
26317     }
26318     return resultobj;
26319     fail:
26320     return NULL;
26321 }
26322
26323
26324 static PyObject *_wrap_ListCtrl_InsertColumn(PyObject *, PyObject *args, PyObject *kwargs) {
26325     PyObject *resultobj;
26326     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26327     long arg2 ;
26328     wxString *arg3 = 0 ;
26329     int arg4 = (int) wxLIST_FORMAT_LEFT ;
26330     int arg5 = (int) -1 ;
26331     long result;
26332     bool temp3 = false ;
26333     PyObject * obj0 = 0 ;
26334     PyObject * obj1 = 0 ;
26335     PyObject * obj2 = 0 ;
26336     PyObject * obj3 = 0 ;
26337     PyObject * obj4 = 0 ;
26338     char *kwnames[] = {
26339         (char *) "self",(char *) "col",(char *) "heading",(char *) "format",(char *) "width", NULL
26340     };
26341
26342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:ListCtrl_InsertColumn",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26344     if (SWIG_arg_fail(1)) SWIG_fail;
26345     {
26346         arg2 = (long)(SWIG_As_long(obj1));
26347         if (SWIG_arg_fail(2)) SWIG_fail;
26348     }
26349     {
26350         arg3 = wxString_in_helper(obj2);
26351         if (arg3 == NULL) SWIG_fail;
26352         temp3 = true;
26353     }
26354     if (obj3) {
26355         {
26356             arg4 = (int)(SWIG_As_int(obj3));
26357             if (SWIG_arg_fail(4)) SWIG_fail;
26358         }
26359     }
26360     if (obj4) {
26361         {
26362             arg5 = (int)(SWIG_As_int(obj4));
26363             if (SWIG_arg_fail(5)) SWIG_fail;
26364         }
26365     }
26366     {
26367         PyThreadState* __tstate = wxPyBeginAllowThreads();
26368         result = (long)(arg1)->InsertColumn(arg2,(wxString const &)*arg3,arg4,arg5);
26369
26370         wxPyEndAllowThreads(__tstate);
26371         if (PyErr_Occurred()) SWIG_fail;
26372     }
26373     {
26374         resultobj = SWIG_From_long((long)(result));
26375     }
26376     {
26377         if (temp3)
26378         delete arg3;
26379     }
26380     return resultobj;
26381     fail:
26382     {
26383         if (temp3)
26384         delete arg3;
26385     }
26386     return NULL;
26387 }
26388
26389
26390 static PyObject *_wrap_ListCtrl_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
26391     PyObject *resultobj;
26392     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26393     long arg2 ;
26394     PyObject * obj0 = 0 ;
26395     PyObject * obj1 = 0 ;
26396     char *kwnames[] = {
26397         (char *) "self",(char *) "count", NULL
26398     };
26399
26400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItemCount",kwnames,&obj0,&obj1)) 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 = (long)(SWIG_As_long(obj1));
26405         if (SWIG_arg_fail(2)) SWIG_fail;
26406     }
26407     {
26408         PyThreadState* __tstate = wxPyBeginAllowThreads();
26409         (arg1)->SetItemCount(arg2);
26410
26411         wxPyEndAllowThreads(__tstate);
26412         if (PyErr_Occurred()) SWIG_fail;
26413     }
26414     Py_INCREF(Py_None); resultobj = Py_None;
26415     return resultobj;
26416     fail:
26417     return NULL;
26418 }
26419
26420
26421 static PyObject *_wrap_ListCtrl_ScrollList(PyObject *, PyObject *args, PyObject *kwargs) {
26422     PyObject *resultobj;
26423     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26424     int arg2 ;
26425     int arg3 ;
26426     bool result;
26427     PyObject * obj0 = 0 ;
26428     PyObject * obj1 = 0 ;
26429     PyObject * obj2 = 0 ;
26430     char *kwnames[] = {
26431         (char *) "self",(char *) "dx",(char *) "dy", NULL
26432     };
26433
26434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_ScrollList",kwnames,&obj0,&obj1,&obj2)) goto fail;
26435     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26436     if (SWIG_arg_fail(1)) SWIG_fail;
26437     {
26438         arg2 = (int)(SWIG_As_int(obj1));
26439         if (SWIG_arg_fail(2)) SWIG_fail;
26440     }
26441     {
26442         arg3 = (int)(SWIG_As_int(obj2));
26443         if (SWIG_arg_fail(3)) SWIG_fail;
26444     }
26445     {
26446         PyThreadState* __tstate = wxPyBeginAllowThreads();
26447         result = (bool)(arg1)->ScrollList(arg2,arg3);
26448
26449         wxPyEndAllowThreads(__tstate);
26450         if (PyErr_Occurred()) SWIG_fail;
26451     }
26452     {
26453         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26454     }
26455     return resultobj;
26456     fail:
26457     return NULL;
26458 }
26459
26460
26461 static PyObject *_wrap_ListCtrl_SetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
26462     PyObject *resultobj;
26463     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26464     long arg2 ;
26465     wxColour *arg3 = 0 ;
26466     wxColour temp3 ;
26467     PyObject * obj0 = 0 ;
26468     PyObject * obj1 = 0 ;
26469     PyObject * obj2 = 0 ;
26470     char *kwnames[] = {
26471         (char *) "self",(char *) "item",(char *) "col", NULL
26472     };
26473
26474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
26475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26476     if (SWIG_arg_fail(1)) SWIG_fail;
26477     {
26478         arg2 = (long)(SWIG_As_long(obj1));
26479         if (SWIG_arg_fail(2)) SWIG_fail;
26480     }
26481     {
26482         arg3 = &temp3;
26483         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26484     }
26485     {
26486         PyThreadState* __tstate = wxPyBeginAllowThreads();
26487         (arg1)->SetItemTextColour(arg2,(wxColour const &)*arg3);
26488
26489         wxPyEndAllowThreads(__tstate);
26490         if (PyErr_Occurred()) SWIG_fail;
26491     }
26492     Py_INCREF(Py_None); resultobj = Py_None;
26493     return resultobj;
26494     fail:
26495     return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_ListCtrl_GetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
26500     PyObject *resultobj;
26501     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26502     long arg2 ;
26503     wxColour result;
26504     PyObject * obj0 = 0 ;
26505     PyObject * obj1 = 0 ;
26506     char *kwnames[] = {
26507         (char *) "self",(char *) "item", NULL
26508     };
26509
26510     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) goto fail;
26511     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26512     if (SWIG_arg_fail(1)) SWIG_fail;
26513     {
26514         arg2 = (long)(SWIG_As_long(obj1));
26515         if (SWIG_arg_fail(2)) SWIG_fail;
26516     }
26517     {
26518         PyThreadState* __tstate = wxPyBeginAllowThreads();
26519         result = ((wxPyListCtrl const *)arg1)->GetItemTextColour(arg2);
26520
26521         wxPyEndAllowThreads(__tstate);
26522         if (PyErr_Occurred()) SWIG_fail;
26523     }
26524     {
26525         wxColour * resultptr;
26526         resultptr = new wxColour((wxColour &)(result));
26527         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
26528     }
26529     return resultobj;
26530     fail:
26531     return NULL;
26532 }
26533
26534
26535 static PyObject *_wrap_ListCtrl_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
26536     PyObject *resultobj;
26537     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26538     long arg2 ;
26539     wxColour *arg3 = 0 ;
26540     wxColour temp3 ;
26541     PyObject * obj0 = 0 ;
26542     PyObject * obj1 = 0 ;
26543     PyObject * obj2 = 0 ;
26544     char *kwnames[] = {
26545         (char *) "self",(char *) "item",(char *) "col", NULL
26546     };
26547
26548     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
26549     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26550     if (SWIG_arg_fail(1)) SWIG_fail;
26551     {
26552         arg2 = (long)(SWIG_As_long(obj1));
26553         if (SWIG_arg_fail(2)) SWIG_fail;
26554     }
26555     {
26556         arg3 = &temp3;
26557         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26558     }
26559     {
26560         PyThreadState* __tstate = wxPyBeginAllowThreads();
26561         (arg1)->SetItemBackgroundColour(arg2,(wxColour const &)*arg3);
26562
26563         wxPyEndAllowThreads(__tstate);
26564         if (PyErr_Occurred()) SWIG_fail;
26565     }
26566     Py_INCREF(Py_None); resultobj = Py_None;
26567     return resultobj;
26568     fail:
26569     return NULL;
26570 }
26571
26572
26573 static PyObject *_wrap_ListCtrl_GetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
26574     PyObject *resultobj;
26575     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26576     long arg2 ;
26577     wxColour result;
26578     PyObject * obj0 = 0 ;
26579     PyObject * obj1 = 0 ;
26580     char *kwnames[] = {
26581         (char *) "self",(char *) "item", NULL
26582     };
26583
26584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
26585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26586     if (SWIG_arg_fail(1)) SWIG_fail;
26587     {
26588         arg2 = (long)(SWIG_As_long(obj1));
26589         if (SWIG_arg_fail(2)) SWIG_fail;
26590     }
26591     {
26592         PyThreadState* __tstate = wxPyBeginAllowThreads();
26593         result = ((wxPyListCtrl const *)arg1)->GetItemBackgroundColour(arg2);
26594
26595         wxPyEndAllowThreads(__tstate);
26596         if (PyErr_Occurred()) SWIG_fail;
26597     }
26598     {
26599         wxColour * resultptr;
26600         resultptr = new wxColour((wxColour &)(result));
26601         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
26602     }
26603     return resultobj;
26604     fail:
26605     return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_ListCtrl_SortItems(PyObject *, PyObject *args, PyObject *kwargs) {
26610     PyObject *resultobj;
26611     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26612     PyObject *arg2 = (PyObject *) 0 ;
26613     bool result;
26614     PyObject * obj0 = 0 ;
26615     PyObject * obj1 = 0 ;
26616     char *kwnames[] = {
26617         (char *) "self",(char *) "func", NULL
26618     };
26619
26620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SortItems",kwnames,&obj0,&obj1)) goto fail;
26621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26622     if (SWIG_arg_fail(1)) SWIG_fail;
26623     arg2 = obj1;
26624     {
26625         PyThreadState* __tstate = wxPyBeginAllowThreads();
26626         result = (bool)wxPyListCtrl_SortItems(arg1,arg2);
26627
26628         wxPyEndAllowThreads(__tstate);
26629         if (PyErr_Occurred()) SWIG_fail;
26630     }
26631     {
26632         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26633     }
26634     return resultobj;
26635     fail:
26636     return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_ListCtrl_GetMainWindow(PyObject *, PyObject *args, PyObject *kwargs) {
26641     PyObject *resultobj;
26642     wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
26643     wxWindow *result;
26644     PyObject * obj0 = 0 ;
26645     char *kwnames[] = {
26646         (char *) "self", NULL
26647     };
26648
26649     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListCtrl_GetMainWindow",kwnames,&obj0)) goto fail;
26650     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
26651     if (SWIG_arg_fail(1)) SWIG_fail;
26652     {
26653         PyThreadState* __tstate = wxPyBeginAllowThreads();
26654         result = (wxWindow *)wxPyListCtrl_GetMainWindow(arg1);
26655
26656         wxPyEndAllowThreads(__tstate);
26657         if (PyErr_Occurred()) SWIG_fail;
26658     }
26659     {
26660         resultobj = wxPyMake_wxObject(result, 0);
26661     }
26662     return resultobj;
26663     fail:
26664     return NULL;
26665 }
26666
26667
26668 static PyObject *_wrap_ListCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
26669     PyObject *resultobj;
26670     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
26671     wxVisualAttributes result;
26672     PyObject * obj0 = 0 ;
26673     char *kwnames[] = {
26674         (char *) "variant", NULL
26675     };
26676
26677     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
26678     if (obj0) {
26679         {
26680             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
26681             if (SWIG_arg_fail(1)) SWIG_fail;
26682         }
26683     }
26684     {
26685         if (!wxPyCheckForApp()) SWIG_fail;
26686         PyThreadState* __tstate = wxPyBeginAllowThreads();
26687         result = wxPyListCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
26688
26689         wxPyEndAllowThreads(__tstate);
26690         if (PyErr_Occurred()) SWIG_fail;
26691     }
26692     {
26693         wxVisualAttributes * resultptr;
26694         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
26695         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
26696     }
26697     return resultobj;
26698     fail:
26699     return NULL;
26700 }
26701
26702
26703 static PyObject * ListCtrl_swigregister(PyObject *, PyObject *args) {
26704     PyObject *obj;
26705     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26706     SWIG_TypeClientData(SWIGTYPE_p_wxPyListCtrl, obj);
26707     Py_INCREF(obj);
26708     return Py_BuildValue((char *)"");
26709 }
26710 static PyObject *_wrap_new_ListView(PyObject *, PyObject *args, PyObject *kwargs) {
26711     PyObject *resultobj;
26712     wxWindow *arg1 = (wxWindow *) 0 ;
26713     int arg2 = (int) -1 ;
26714     wxPoint const &arg3_defvalue = wxDefaultPosition ;
26715     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26716     wxSize const &arg4_defvalue = wxDefaultSize ;
26717     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26718     long arg5 = (long) wxLC_REPORT ;
26719     wxValidator const &arg6_defvalue = wxDefaultValidator ;
26720     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
26721     wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
26722     wxString *arg7 = (wxString *) &arg7_defvalue ;
26723     wxListView *result;
26724     wxPoint temp3 ;
26725     wxSize temp4 ;
26726     bool temp7 = false ;
26727     PyObject * obj0 = 0 ;
26728     PyObject * obj1 = 0 ;
26729     PyObject * obj2 = 0 ;
26730     PyObject * obj3 = 0 ;
26731     PyObject * obj4 = 0 ;
26732     PyObject * obj5 = 0 ;
26733     PyObject * obj6 = 0 ;
26734     char *kwnames[] = {
26735         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
26736     };
26737
26738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListView",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26739     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26740     if (SWIG_arg_fail(1)) SWIG_fail;
26741     if (obj1) {
26742         {
26743             arg2 = (int)(SWIG_As_int(obj1));
26744             if (SWIG_arg_fail(2)) SWIG_fail;
26745         }
26746     }
26747     if (obj2) {
26748         {
26749             arg3 = &temp3;
26750             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26751         }
26752     }
26753     if (obj3) {
26754         {
26755             arg4 = &temp4;
26756             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26757         }
26758     }
26759     if (obj4) {
26760         {
26761             arg5 = (long)(SWIG_As_long(obj4));
26762             if (SWIG_arg_fail(5)) SWIG_fail;
26763         }
26764     }
26765     if (obj5) {
26766         {
26767             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
26768             if (SWIG_arg_fail(6)) SWIG_fail;
26769             if (arg6 == NULL) {
26770                 SWIG_null_ref("wxValidator");
26771             }
26772             if (SWIG_arg_fail(6)) SWIG_fail;
26773         }
26774     }
26775     if (obj6) {
26776         {
26777             arg7 = wxString_in_helper(obj6);
26778             if (arg7 == NULL) SWIG_fail;
26779             temp7 = true;
26780         }
26781     }
26782     {
26783         if (!wxPyCheckForApp()) SWIG_fail;
26784         PyThreadState* __tstate = wxPyBeginAllowThreads();
26785         result = (wxListView *)new wxListView(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
26786
26787         wxPyEndAllowThreads(__tstate);
26788         if (PyErr_Occurred()) SWIG_fail;
26789     }
26790     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 1);
26791     {
26792         if (temp7)
26793         delete arg7;
26794     }
26795     return resultobj;
26796     fail:
26797     {
26798         if (temp7)
26799         delete arg7;
26800     }
26801     return NULL;
26802 }
26803
26804
26805 static PyObject *_wrap_new_PreListView(PyObject *, PyObject *args, PyObject *kwargs) {
26806     PyObject *resultobj;
26807     wxListView *result;
26808     char *kwnames[] = {
26809         NULL
26810     };
26811
26812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreListView",kwnames)) goto fail;
26813     {
26814         if (!wxPyCheckForApp()) SWIG_fail;
26815         PyThreadState* __tstate = wxPyBeginAllowThreads();
26816         result = (wxListView *)new wxListView();
26817
26818         wxPyEndAllowThreads(__tstate);
26819         if (PyErr_Occurred()) SWIG_fail;
26820     }
26821     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxListView, 1);
26822     return resultobj;
26823     fail:
26824     return NULL;
26825 }
26826
26827
26828 static PyObject *_wrap_ListView_Create(PyObject *, PyObject *args, PyObject *kwargs) {
26829     PyObject *resultobj;
26830     wxListView *arg1 = (wxListView *) 0 ;
26831     wxWindow *arg2 = (wxWindow *) 0 ;
26832     int arg3 = (int) -1 ;
26833     wxPoint const &arg4_defvalue = wxDefaultPosition ;
26834     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
26835     wxSize const &arg5_defvalue = wxDefaultSize ;
26836     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
26837     long arg6 = (long) wxLC_REPORT ;
26838     wxValidator const &arg7_defvalue = wxDefaultValidator ;
26839     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
26840     wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
26841     wxString *arg8 = (wxString *) &arg8_defvalue ;
26842     bool result;
26843     wxPoint temp4 ;
26844     wxSize temp5 ;
26845     bool temp8 = false ;
26846     PyObject * obj0 = 0 ;
26847     PyObject * obj1 = 0 ;
26848     PyObject * obj2 = 0 ;
26849     PyObject * obj3 = 0 ;
26850     PyObject * obj4 = 0 ;
26851     PyObject * obj5 = 0 ;
26852     PyObject * obj6 = 0 ;
26853     PyObject * obj7 = 0 ;
26854     char *kwnames[] = {
26855         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
26856     };
26857
26858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListView_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
26859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26860     if (SWIG_arg_fail(1)) SWIG_fail;
26861     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26862     if (SWIG_arg_fail(2)) SWIG_fail;
26863     if (obj2) {
26864         {
26865             arg3 = (int)(SWIG_As_int(obj2));
26866             if (SWIG_arg_fail(3)) SWIG_fail;
26867         }
26868     }
26869     if (obj3) {
26870         {
26871             arg4 = &temp4;
26872             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
26873         }
26874     }
26875     if (obj4) {
26876         {
26877             arg5 = &temp5;
26878             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
26879         }
26880     }
26881     if (obj5) {
26882         {
26883             arg6 = (long)(SWIG_As_long(obj5));
26884             if (SWIG_arg_fail(6)) SWIG_fail;
26885         }
26886     }
26887     if (obj6) {
26888         {
26889             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
26890             if (SWIG_arg_fail(7)) SWIG_fail;
26891             if (arg7 == NULL) {
26892                 SWIG_null_ref("wxValidator");
26893             }
26894             if (SWIG_arg_fail(7)) SWIG_fail;
26895         }
26896     }
26897     if (obj7) {
26898         {
26899             arg8 = wxString_in_helper(obj7);
26900             if (arg8 == NULL) SWIG_fail;
26901             temp8 = true;
26902         }
26903     }
26904     {
26905         PyThreadState* __tstate = wxPyBeginAllowThreads();
26906         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
26907
26908         wxPyEndAllowThreads(__tstate);
26909         if (PyErr_Occurred()) SWIG_fail;
26910     }
26911     {
26912         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26913     }
26914     {
26915         if (temp8)
26916         delete arg8;
26917     }
26918     return resultobj;
26919     fail:
26920     {
26921         if (temp8)
26922         delete arg8;
26923     }
26924     return NULL;
26925 }
26926
26927
26928 static PyObject *_wrap_ListView_Select(PyObject *, PyObject *args, PyObject *kwargs) {
26929     PyObject *resultobj;
26930     wxListView *arg1 = (wxListView *) 0 ;
26931     long arg2 ;
26932     bool arg3 = (bool) true ;
26933     PyObject * obj0 = 0 ;
26934     PyObject * obj1 = 0 ;
26935     PyObject * obj2 = 0 ;
26936     char *kwnames[] = {
26937         (char *) "self",(char *) "n",(char *) "on", NULL
26938     };
26939
26940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListView_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
26941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26942     if (SWIG_arg_fail(1)) SWIG_fail;
26943     {
26944         arg2 = (long)(SWIG_As_long(obj1));
26945         if (SWIG_arg_fail(2)) SWIG_fail;
26946     }
26947     if (obj2) {
26948         {
26949             arg3 = (bool)(SWIG_As_bool(obj2));
26950             if (SWIG_arg_fail(3)) SWIG_fail;
26951         }
26952     }
26953     {
26954         PyThreadState* __tstate = wxPyBeginAllowThreads();
26955         (arg1)->Select(arg2,arg3);
26956
26957         wxPyEndAllowThreads(__tstate);
26958         if (PyErr_Occurred()) SWIG_fail;
26959     }
26960     Py_INCREF(Py_None); resultobj = Py_None;
26961     return resultobj;
26962     fail:
26963     return NULL;
26964 }
26965
26966
26967 static PyObject *_wrap_ListView_Focus(PyObject *, PyObject *args, PyObject *kwargs) {
26968     PyObject *resultobj;
26969     wxListView *arg1 = (wxListView *) 0 ;
26970     long arg2 ;
26971     PyObject * obj0 = 0 ;
26972     PyObject * obj1 = 0 ;
26973     char *kwnames[] = {
26974         (char *) "self",(char *) "index", NULL
26975     };
26976
26977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_Focus",kwnames,&obj0,&obj1)) goto fail;
26978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
26979     if (SWIG_arg_fail(1)) SWIG_fail;
26980     {
26981         arg2 = (long)(SWIG_As_long(obj1));
26982         if (SWIG_arg_fail(2)) SWIG_fail;
26983     }
26984     {
26985         PyThreadState* __tstate = wxPyBeginAllowThreads();
26986         (arg1)->Focus(arg2);
26987
26988         wxPyEndAllowThreads(__tstate);
26989         if (PyErr_Occurred()) SWIG_fail;
26990     }
26991     Py_INCREF(Py_None); resultobj = Py_None;
26992     return resultobj;
26993     fail:
26994     return NULL;
26995 }
26996
26997
26998 static PyObject *_wrap_ListView_GetFocusedItem(PyObject *, PyObject *args, PyObject *kwargs) {
26999     PyObject *resultobj;
27000     wxListView *arg1 = (wxListView *) 0 ;
27001     long result;
27002     PyObject * obj0 = 0 ;
27003     char *kwnames[] = {
27004         (char *) "self", NULL
27005     };
27006
27007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListView_GetFocusedItem",kwnames,&obj0)) goto fail;
27008     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27009     if (SWIG_arg_fail(1)) SWIG_fail;
27010     {
27011         PyThreadState* __tstate = wxPyBeginAllowThreads();
27012         result = (long)((wxListView const *)arg1)->GetFocusedItem();
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_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
27027     PyObject *resultobj;
27028     wxListView *arg1 = (wxListView *) 0 ;
27029     long arg2 ;
27030     long result;
27031     PyObject * obj0 = 0 ;
27032     PyObject * obj1 = 0 ;
27033     char *kwnames[] = {
27034         (char *) "self",(char *) "item", NULL
27035     };
27036
27037     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
27038     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27039     if (SWIG_arg_fail(1)) SWIG_fail;
27040     {
27041         arg2 = (long)(SWIG_As_long(obj1));
27042         if (SWIG_arg_fail(2)) SWIG_fail;
27043     }
27044     {
27045         PyThreadState* __tstate = wxPyBeginAllowThreads();
27046         result = (long)((wxListView const *)arg1)->GetNextSelected(arg2);
27047
27048         wxPyEndAllowThreads(__tstate);
27049         if (PyErr_Occurred()) SWIG_fail;
27050     }
27051     {
27052         resultobj = SWIG_From_long((long)(result));
27053     }
27054     return resultobj;
27055     fail:
27056     return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_ListView_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
27061     PyObject *resultobj;
27062     wxListView *arg1 = (wxListView *) 0 ;
27063     long result;
27064     PyObject * obj0 = 0 ;
27065     char *kwnames[] = {
27066         (char *) "self", NULL
27067     };
27068
27069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListView_GetFirstSelected",kwnames,&obj0)) goto fail;
27070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27071     if (SWIG_arg_fail(1)) SWIG_fail;
27072     {
27073         PyThreadState* __tstate = wxPyBeginAllowThreads();
27074         result = (long)((wxListView const *)arg1)->GetFirstSelected();
27075
27076         wxPyEndAllowThreads(__tstate);
27077         if (PyErr_Occurred()) SWIG_fail;
27078     }
27079     {
27080         resultobj = SWIG_From_long((long)(result));
27081     }
27082     return resultobj;
27083     fail:
27084     return NULL;
27085 }
27086
27087
27088 static PyObject *_wrap_ListView_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
27089     PyObject *resultobj;
27090     wxListView *arg1 = (wxListView *) 0 ;
27091     long arg2 ;
27092     bool result;
27093     PyObject * obj0 = 0 ;
27094     PyObject * obj1 = 0 ;
27095     char *kwnames[] = {
27096         (char *) "self",(char *) "index", NULL
27097     };
27098
27099     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_IsSelected",kwnames,&obj0,&obj1)) goto fail;
27100     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27101     if (SWIG_arg_fail(1)) SWIG_fail;
27102     {
27103         arg2 = (long)(SWIG_As_long(obj1));
27104         if (SWIG_arg_fail(2)) SWIG_fail;
27105     }
27106     {
27107         PyThreadState* __tstate = wxPyBeginAllowThreads();
27108         result = (bool)(arg1)->IsSelected(arg2);
27109
27110         wxPyEndAllowThreads(__tstate);
27111         if (PyErr_Occurred()) SWIG_fail;
27112     }
27113     {
27114         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27115     }
27116     return resultobj;
27117     fail:
27118     return NULL;
27119 }
27120
27121
27122 static PyObject *_wrap_ListView_SetColumnImage(PyObject *, PyObject *args, PyObject *kwargs) {
27123     PyObject *resultobj;
27124     wxListView *arg1 = (wxListView *) 0 ;
27125     int arg2 ;
27126     int arg3 ;
27127     PyObject * obj0 = 0 ;
27128     PyObject * obj1 = 0 ;
27129     PyObject * obj2 = 0 ;
27130     char *kwnames[] = {
27131         (char *) "self",(char *) "col",(char *) "image", NULL
27132     };
27133
27134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListView_SetColumnImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27136     if (SWIG_arg_fail(1)) SWIG_fail;
27137     {
27138         arg2 = (int)(SWIG_As_int(obj1));
27139         if (SWIG_arg_fail(2)) SWIG_fail;
27140     }
27141     {
27142         arg3 = (int)(SWIG_As_int(obj2));
27143         if (SWIG_arg_fail(3)) SWIG_fail;
27144     }
27145     {
27146         PyThreadState* __tstate = wxPyBeginAllowThreads();
27147         (arg1)->SetColumnImage(arg2,arg3);
27148
27149         wxPyEndAllowThreads(__tstate);
27150         if (PyErr_Occurred()) SWIG_fail;
27151     }
27152     Py_INCREF(Py_None); resultobj = Py_None;
27153     return resultobj;
27154     fail:
27155     return NULL;
27156 }
27157
27158
27159 static PyObject *_wrap_ListView_ClearColumnImage(PyObject *, PyObject *args, PyObject *kwargs) {
27160     PyObject *resultobj;
27161     wxListView *arg1 = (wxListView *) 0 ;
27162     int arg2 ;
27163     PyObject * obj0 = 0 ;
27164     PyObject * obj1 = 0 ;
27165     char *kwnames[] = {
27166         (char *) "self",(char *) "col", NULL
27167     };
27168
27169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_ClearColumnImage",kwnames,&obj0,&obj1)) goto fail;
27170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxListView, SWIG_POINTER_EXCEPTION | 0);
27171     if (SWIG_arg_fail(1)) SWIG_fail;
27172     {
27173         arg2 = (int)(SWIG_As_int(obj1));
27174         if (SWIG_arg_fail(2)) SWIG_fail;
27175     }
27176     {
27177         PyThreadState* __tstate = wxPyBeginAllowThreads();
27178         (arg1)->ClearColumnImage(arg2);
27179
27180         wxPyEndAllowThreads(__tstate);
27181         if (PyErr_Occurred()) SWIG_fail;
27182     }
27183     Py_INCREF(Py_None); resultobj = Py_None;
27184     return resultobj;
27185     fail:
27186     return NULL;
27187 }
27188
27189
27190 static PyObject * ListView_swigregister(PyObject *, PyObject *args) {
27191     PyObject *obj;
27192     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27193     SWIG_TypeClientData(SWIGTYPE_p_wxListView, obj);
27194     Py_INCREF(obj);
27195     return Py_BuildValue((char *)"");
27196 }
27197 static int _wrap_TreeCtrlNameStr_set(PyObject *) {
27198     PyErr_SetString(PyExc_TypeError,"Variable TreeCtrlNameStr is read-only.");
27199     return 1;
27200 }
27201
27202
27203 static PyObject *_wrap_TreeCtrlNameStr_get(void) {
27204     PyObject *pyobj;
27205
27206     {
27207 #if wxUSE_UNICODE
27208         pyobj = PyUnicode_FromWideChar((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
27209 #else
27210         pyobj = PyString_FromStringAndSize((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
27211 #endif
27212     }
27213     return pyobj;
27214 }
27215
27216
27217 static PyObject *_wrap_new_TreeItemId(PyObject *, PyObject *args, PyObject *kwargs) {
27218     PyObject *resultobj;
27219     wxTreeItemId *result;
27220     char *kwnames[] = {
27221         NULL
27222     };
27223
27224     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TreeItemId",kwnames)) goto fail;
27225     {
27226         PyThreadState* __tstate = wxPyBeginAllowThreads();
27227         result = (wxTreeItemId *)new wxTreeItemId();
27228
27229         wxPyEndAllowThreads(__tstate);
27230         if (PyErr_Occurred()) SWIG_fail;
27231     }
27232     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeItemId, 1);
27233     return resultobj;
27234     fail:
27235     return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_delete_TreeItemId(PyObject *, PyObject *args, PyObject *kwargs) {
27240     PyObject *resultobj;
27241     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27242     PyObject * obj0 = 0 ;
27243     char *kwnames[] = {
27244         (char *) "self", NULL
27245     };
27246
27247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TreeItemId",kwnames,&obj0)) goto fail;
27248     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27249     if (SWIG_arg_fail(1)) SWIG_fail;
27250     {
27251         PyThreadState* __tstate = wxPyBeginAllowThreads();
27252         delete arg1;
27253
27254         wxPyEndAllowThreads(__tstate);
27255         if (PyErr_Occurred()) SWIG_fail;
27256     }
27257     Py_INCREF(Py_None); resultobj = Py_None;
27258     return resultobj;
27259     fail:
27260     return NULL;
27261 }
27262
27263
27264 static PyObject *_wrap_TreeItemId_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
27265     PyObject *resultobj;
27266     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27267     bool result;
27268     PyObject * obj0 = 0 ;
27269     char *kwnames[] = {
27270         (char *) "self", NULL
27271     };
27272
27273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemId_IsOk",kwnames,&obj0)) goto fail;
27274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27275     if (SWIG_arg_fail(1)) SWIG_fail;
27276     {
27277         PyThreadState* __tstate = wxPyBeginAllowThreads();
27278         result = (bool)((wxTreeItemId const *)arg1)->IsOk();
27279
27280         wxPyEndAllowThreads(__tstate);
27281         if (PyErr_Occurred()) SWIG_fail;
27282     }
27283     {
27284         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27285     }
27286     return resultobj;
27287     fail:
27288     return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_TreeItemId___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27293     PyObject *resultobj;
27294     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27295     wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
27296     bool result;
27297     PyObject * obj0 = 0 ;
27298     PyObject * obj1 = 0 ;
27299     char *kwnames[] = {
27300         (char *) "self",(char *) "other", NULL
27301     };
27302
27303     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___eq__",kwnames,&obj0,&obj1)) goto fail;
27304     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27305     if (SWIG_arg_fail(1)) SWIG_fail;
27306     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27307     if (SWIG_arg_fail(2)) SWIG_fail;
27308     {
27309         PyThreadState* __tstate = wxPyBeginAllowThreads();
27310         result = (bool)wxTreeItemId___eq__(arg1,(wxTreeItemId const *)arg2);
27311
27312         wxPyEndAllowThreads(__tstate);
27313         if (PyErr_Occurred()) SWIG_fail;
27314     }
27315     {
27316         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27317     }
27318     return resultobj;
27319     fail:
27320     return NULL;
27321 }
27322
27323
27324 static PyObject *_wrap_TreeItemId___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27325     PyObject *resultobj;
27326     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27327     wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
27328     bool result;
27329     PyObject * obj0 = 0 ;
27330     PyObject * obj1 = 0 ;
27331     char *kwnames[] = {
27332         (char *) "self",(char *) "other", NULL
27333     };
27334
27335     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___ne__",kwnames,&obj0,&obj1)) goto fail;
27336     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27337     if (SWIG_arg_fail(1)) SWIG_fail;
27338     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27339     if (SWIG_arg_fail(2)) SWIG_fail;
27340     {
27341         PyThreadState* __tstate = wxPyBeginAllowThreads();
27342         result = (bool)wxTreeItemId___ne__(arg1,(wxTreeItemId const *)arg2);
27343
27344         wxPyEndAllowThreads(__tstate);
27345         if (PyErr_Occurred()) SWIG_fail;
27346     }
27347     {
27348         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27349     }
27350     return resultobj;
27351     fail:
27352     return NULL;
27353 }
27354
27355
27356 static PyObject *_wrap_TreeItemId_m_pItem_set(PyObject *, PyObject *args, PyObject *kwargs) {
27357     PyObject *resultobj;
27358     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27359     void *arg2 = (void *) 0 ;
27360     PyObject * obj0 = 0 ;
27361     PyObject * obj1 = 0 ;
27362     char *kwnames[] = {
27363         (char *) "self",(char *) "m_pItem", NULL
27364     };
27365
27366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId_m_pItem_set",kwnames,&obj0,&obj1)) goto fail;
27367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27368     if (SWIG_arg_fail(1)) SWIG_fail;
27369     {
27370         if ((SWIG_ConvertPtr(obj1,(void **)(&arg2),0,SWIG_POINTER_EXCEPTION|SWIG_POINTER_DISOWN))== -1) {
27371             SWIG_arg_fail(2);SWIG_fail;
27372         }
27373     }
27374     if (arg1) (arg1)->m_pItem = arg2;
27375
27376     Py_INCREF(Py_None); resultobj = Py_None;
27377     return resultobj;
27378     fail:
27379     return NULL;
27380 }
27381
27382
27383 static PyObject *_wrap_TreeItemId_m_pItem_get(PyObject *, PyObject *args, PyObject *kwargs) {
27384     PyObject *resultobj;
27385     wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
27386     void *result;
27387     PyObject * obj0 = 0 ;
27388     char *kwnames[] = {
27389         (char *) "self", NULL
27390     };
27391
27392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemId_m_pItem_get",kwnames,&obj0)) goto fail;
27393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27394     if (SWIG_arg_fail(1)) SWIG_fail;
27395     result = (void *) ((arg1)->m_pItem);
27396
27397     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
27398     return resultobj;
27399     fail:
27400     return NULL;
27401 }
27402
27403
27404 static PyObject * TreeItemId_swigregister(PyObject *, PyObject *args) {
27405     PyObject *obj;
27406     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27407     SWIG_TypeClientData(SWIGTYPE_p_wxTreeItemId, obj);
27408     Py_INCREF(obj);
27409     return Py_BuildValue((char *)"");
27410 }
27411 static PyObject *_wrap_new_TreeItemData(PyObject *, PyObject *args, PyObject *kwargs) {
27412     PyObject *resultobj;
27413     PyObject *arg1 = (PyObject *) NULL ;
27414     wxPyTreeItemData *result;
27415     PyObject * obj0 = 0 ;
27416     char *kwnames[] = {
27417         (char *) "obj", NULL
27418     };
27419
27420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TreeItemData",kwnames,&obj0)) goto fail;
27421     if (obj0) {
27422         arg1 = obj0;
27423     }
27424     {
27425         PyThreadState* __tstate = wxPyBeginAllowThreads();
27426         result = (wxPyTreeItemData *)new wxPyTreeItemData(arg1);
27427
27428         wxPyEndAllowThreads(__tstate);
27429         if (PyErr_Occurred()) SWIG_fail;
27430     }
27431     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeItemData, 1);
27432     return resultobj;
27433     fail:
27434     return NULL;
27435 }
27436
27437
27438 static PyObject *_wrap_TreeItemData_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27439     PyObject *resultobj;
27440     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27441     PyObject *result;
27442     PyObject * obj0 = 0 ;
27443     char *kwnames[] = {
27444         (char *) "self", NULL
27445     };
27446
27447     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_GetData",kwnames,&obj0)) goto fail;
27448     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27449     if (SWIG_arg_fail(1)) SWIG_fail;
27450     {
27451         PyThreadState* __tstate = wxPyBeginAllowThreads();
27452         result = (PyObject *)(arg1)->GetData();
27453
27454         wxPyEndAllowThreads(__tstate);
27455         if (PyErr_Occurred()) SWIG_fail;
27456     }
27457     resultobj = result;
27458     return resultobj;
27459     fail:
27460     return NULL;
27461 }
27462
27463
27464 static PyObject *_wrap_TreeItemData_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27465     PyObject *resultobj;
27466     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27467     PyObject *arg2 = (PyObject *) 0 ;
27468     PyObject * obj0 = 0 ;
27469     PyObject * obj1 = 0 ;
27470     char *kwnames[] = {
27471         (char *) "self",(char *) "obj", NULL
27472     };
27473
27474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetData",kwnames,&obj0,&obj1)) goto fail;
27475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27476     if (SWIG_arg_fail(1)) SWIG_fail;
27477     arg2 = obj1;
27478     {
27479         PyThreadState* __tstate = wxPyBeginAllowThreads();
27480         (arg1)->SetData(arg2);
27481
27482         wxPyEndAllowThreads(__tstate);
27483         if (PyErr_Occurred()) SWIG_fail;
27484     }
27485     Py_INCREF(Py_None); resultobj = Py_None;
27486     return resultobj;
27487     fail:
27488     return NULL;
27489 }
27490
27491
27492 static PyObject *_wrap_TreeItemData_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27493     PyObject *resultobj;
27494     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27495     wxTreeItemId *result;
27496     PyObject * obj0 = 0 ;
27497     char *kwnames[] = {
27498         (char *) "self", NULL
27499     };
27500
27501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_GetId",kwnames,&obj0)) goto fail;
27502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27503     if (SWIG_arg_fail(1)) SWIG_fail;
27504     {
27505         PyThreadState* __tstate = wxPyBeginAllowThreads();
27506         {
27507             wxTreeItemId const &_result_ref = (arg1)->GetId();
27508             result = (wxTreeItemId *) &_result_ref;
27509         }
27510
27511         wxPyEndAllowThreads(__tstate);
27512         if (PyErr_Occurred()) SWIG_fail;
27513     }
27514     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeItemId, 0);
27515     return resultobj;
27516     fail:
27517     return NULL;
27518 }
27519
27520
27521 static PyObject *_wrap_TreeItemData_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27522     PyObject *resultobj;
27523     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27524     wxTreeItemId *arg2 = 0 ;
27525     PyObject * obj0 = 0 ;
27526     PyObject * obj1 = 0 ;
27527     char *kwnames[] = {
27528         (char *) "self",(char *) "id", NULL
27529     };
27530
27531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetId",kwnames,&obj0,&obj1)) goto fail;
27532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27533     if (SWIG_arg_fail(1)) SWIG_fail;
27534     {
27535         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27536         if (SWIG_arg_fail(2)) SWIG_fail;
27537         if (arg2 == NULL) {
27538             SWIG_null_ref("wxTreeItemId");
27539         }
27540         if (SWIG_arg_fail(2)) SWIG_fail;
27541     }
27542     {
27543         PyThreadState* __tstate = wxPyBeginAllowThreads();
27544         (arg1)->SetId((wxTreeItemId const &)*arg2);
27545
27546         wxPyEndAllowThreads(__tstate);
27547         if (PyErr_Occurred()) SWIG_fail;
27548     }
27549     Py_INCREF(Py_None); resultobj = Py_None;
27550     return resultobj;
27551     fail:
27552     return NULL;
27553 }
27554
27555
27556 static PyObject *_wrap_TreeItemData_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
27557     PyObject *resultobj;
27558     wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
27559     PyObject * obj0 = 0 ;
27560     char *kwnames[] = {
27561         (char *) "self", NULL
27562     };
27563
27564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeItemData_Destroy",kwnames,&obj0)) goto fail;
27565     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
27566     if (SWIG_arg_fail(1)) SWIG_fail;
27567     {
27568         PyThreadState* __tstate = wxPyBeginAllowThreads();
27569         wxPyTreeItemData_Destroy(arg1);
27570
27571         wxPyEndAllowThreads(__tstate);
27572         if (PyErr_Occurred()) SWIG_fail;
27573     }
27574     Py_INCREF(Py_None); resultobj = Py_None;
27575     return resultobj;
27576     fail:
27577     return NULL;
27578 }
27579
27580
27581 static PyObject * TreeItemData_swigregister(PyObject *, PyObject *args) {
27582     PyObject *obj;
27583     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27584     SWIG_TypeClientData(SWIGTYPE_p_wxPyTreeItemData, obj);
27585     Py_INCREF(obj);
27586     return Py_BuildValue((char *)"");
27587 }
27588 static PyObject *_wrap_new_TreeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27589     PyObject *resultobj;
27590     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27591     int arg2 = (int) 0 ;
27592     wxTreeEvent *result;
27593     PyObject * obj0 = 0 ;
27594     PyObject * obj1 = 0 ;
27595     char *kwnames[] = {
27596         (char *) "commandType",(char *) "id", NULL
27597     };
27598
27599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TreeEvent",kwnames,&obj0,&obj1)) goto fail;
27600     if (obj0) {
27601         {
27602             arg1 = (wxEventType)(SWIG_As_int(obj0));
27603             if (SWIG_arg_fail(1)) SWIG_fail;
27604         }
27605     }
27606     if (obj1) {
27607         {
27608             arg2 = (int)(SWIG_As_int(obj1));
27609             if (SWIG_arg_fail(2)) SWIG_fail;
27610         }
27611     }
27612     {
27613         PyThreadState* __tstate = wxPyBeginAllowThreads();
27614         result = (wxTreeEvent *)new wxTreeEvent(arg1,arg2);
27615
27616         wxPyEndAllowThreads(__tstate);
27617         if (PyErr_Occurred()) SWIG_fail;
27618     }
27619     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTreeEvent, 1);
27620     return resultobj;
27621     fail:
27622     return NULL;
27623 }
27624
27625
27626 static PyObject *_wrap_TreeEvent_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
27627     PyObject *resultobj;
27628     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27629     wxTreeItemId result;
27630     PyObject * obj0 = 0 ;
27631     char *kwnames[] = {
27632         (char *) "self", NULL
27633     };
27634
27635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetItem",kwnames,&obj0)) goto fail;
27636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27637     if (SWIG_arg_fail(1)) SWIG_fail;
27638     {
27639         PyThreadState* __tstate = wxPyBeginAllowThreads();
27640         result = ((wxTreeEvent const *)arg1)->GetItem();
27641
27642         wxPyEndAllowThreads(__tstate);
27643         if (PyErr_Occurred()) SWIG_fail;
27644     }
27645     {
27646         wxTreeItemId * resultptr;
27647         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
27648         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
27649     }
27650     return resultobj;
27651     fail:
27652     return NULL;
27653 }
27654
27655
27656 static PyObject *_wrap_TreeEvent_SetItem(PyObject *, PyObject *args, PyObject *kwargs) {
27657     PyObject *resultobj;
27658     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27659     wxTreeItemId *arg2 = 0 ;
27660     PyObject * obj0 = 0 ;
27661     PyObject * obj1 = 0 ;
27662     char *kwnames[] = {
27663         (char *) "self",(char *) "item", NULL
27664     };
27665
27666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetItem",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27671         if (SWIG_arg_fail(2)) SWIG_fail;
27672         if (arg2 == NULL) {
27673             SWIG_null_ref("wxTreeItemId");
27674         }
27675         if (SWIG_arg_fail(2)) SWIG_fail;
27676     }
27677     {
27678         PyThreadState* __tstate = wxPyBeginAllowThreads();
27679         (arg1)->SetItem((wxTreeItemId const &)*arg2);
27680
27681         wxPyEndAllowThreads(__tstate);
27682         if (PyErr_Occurred()) SWIG_fail;
27683     }
27684     Py_INCREF(Py_None); resultobj = Py_None;
27685     return resultobj;
27686     fail:
27687     return NULL;
27688 }
27689
27690
27691 static PyObject *_wrap_TreeEvent_GetOldItem(PyObject *, PyObject *args, PyObject *kwargs) {
27692     PyObject *resultobj;
27693     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27694     wxTreeItemId result;
27695     PyObject * obj0 = 0 ;
27696     char *kwnames[] = {
27697         (char *) "self", NULL
27698     };
27699
27700     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetOldItem",kwnames,&obj0)) goto fail;
27701     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27702     if (SWIG_arg_fail(1)) SWIG_fail;
27703     {
27704         PyThreadState* __tstate = wxPyBeginAllowThreads();
27705         result = ((wxTreeEvent const *)arg1)->GetOldItem();
27706
27707         wxPyEndAllowThreads(__tstate);
27708         if (PyErr_Occurred()) SWIG_fail;
27709     }
27710     {
27711         wxTreeItemId * resultptr;
27712         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
27713         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
27714     }
27715     return resultobj;
27716     fail:
27717     return NULL;
27718 }
27719
27720
27721 static PyObject *_wrap_TreeEvent_SetOldItem(PyObject *, PyObject *args, PyObject *kwargs) {
27722     PyObject *resultobj;
27723     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27724     wxTreeItemId *arg2 = 0 ;
27725     PyObject * obj0 = 0 ;
27726     PyObject * obj1 = 0 ;
27727     char *kwnames[] = {
27728         (char *) "self",(char *) "item", NULL
27729     };
27730
27731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetOldItem",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
27736         if (SWIG_arg_fail(2)) SWIG_fail;
27737         if (arg2 == NULL) {
27738             SWIG_null_ref("wxTreeItemId");
27739         }
27740         if (SWIG_arg_fail(2)) SWIG_fail;
27741     }
27742     {
27743         PyThreadState* __tstate = wxPyBeginAllowThreads();
27744         (arg1)->SetOldItem((wxTreeItemId const &)*arg2);
27745
27746         wxPyEndAllowThreads(__tstate);
27747         if (PyErr_Occurred()) SWIG_fail;
27748     }
27749     Py_INCREF(Py_None); resultobj = Py_None;
27750     return resultobj;
27751     fail:
27752     return NULL;
27753 }
27754
27755
27756 static PyObject *_wrap_TreeEvent_GetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
27757     PyObject *resultobj;
27758     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27759     wxPoint result;
27760     PyObject * obj0 = 0 ;
27761     char *kwnames[] = {
27762         (char *) "self", NULL
27763     };
27764
27765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetPoint",kwnames,&obj0)) goto fail;
27766     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27767     if (SWIG_arg_fail(1)) SWIG_fail;
27768     {
27769         PyThreadState* __tstate = wxPyBeginAllowThreads();
27770         result = ((wxTreeEvent const *)arg1)->GetPoint();
27771
27772         wxPyEndAllowThreads(__tstate);
27773         if (PyErr_Occurred()) SWIG_fail;
27774     }
27775     {
27776         wxPoint * resultptr;
27777         resultptr = new wxPoint((wxPoint &)(result));
27778         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27779     }
27780     return resultobj;
27781     fail:
27782     return NULL;
27783 }
27784
27785
27786 static PyObject *_wrap_TreeEvent_SetPoint(PyObject *, PyObject *args, PyObject *kwargs) {
27787     PyObject *resultobj;
27788     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27789     wxPoint *arg2 = 0 ;
27790     wxPoint temp2 ;
27791     PyObject * obj0 = 0 ;
27792     PyObject * obj1 = 0 ;
27793     char *kwnames[] = {
27794         (char *) "self",(char *) "pt", NULL
27795     };
27796
27797     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetPoint",kwnames,&obj0,&obj1)) goto fail;
27798     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27799     if (SWIG_arg_fail(1)) SWIG_fail;
27800     {
27801         arg2 = &temp2;
27802         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27803     }
27804     {
27805         PyThreadState* __tstate = wxPyBeginAllowThreads();
27806         (arg1)->SetPoint((wxPoint const &)*arg2);
27807
27808         wxPyEndAllowThreads(__tstate);
27809         if (PyErr_Occurred()) SWIG_fail;
27810     }
27811     Py_INCREF(Py_None); resultobj = Py_None;
27812     return resultobj;
27813     fail:
27814     return NULL;
27815 }
27816
27817
27818 static PyObject *_wrap_TreeEvent_GetKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27819     PyObject *resultobj;
27820     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27821     wxKeyEvent *result;
27822     PyObject * obj0 = 0 ;
27823     char *kwnames[] = {
27824         (char *) "self", NULL
27825     };
27826
27827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetKeyEvent",kwnames,&obj0)) goto fail;
27828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27829     if (SWIG_arg_fail(1)) SWIG_fail;
27830     {
27831         PyThreadState* __tstate = wxPyBeginAllowThreads();
27832         {
27833             wxKeyEvent const &_result_ref = ((wxTreeEvent const *)arg1)->GetKeyEvent();
27834             result = (wxKeyEvent *) &_result_ref;
27835         }
27836
27837         wxPyEndAllowThreads(__tstate);
27838         if (PyErr_Occurred()) SWIG_fail;
27839     }
27840     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 0);
27841     return resultobj;
27842     fail:
27843     return NULL;
27844 }
27845
27846
27847 static PyObject *_wrap_TreeEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
27848     PyObject *resultobj;
27849     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27850     int result;
27851     PyObject * obj0 = 0 ;
27852     char *kwnames[] = {
27853         (char *) "self", NULL
27854     };
27855
27856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetKeyCode",kwnames,&obj0)) goto fail;
27857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27858     if (SWIG_arg_fail(1)) SWIG_fail;
27859     {
27860         PyThreadState* __tstate = wxPyBeginAllowThreads();
27861         result = (int)((wxTreeEvent const *)arg1)->GetKeyCode();
27862
27863         wxPyEndAllowThreads(__tstate);
27864         if (PyErr_Occurred()) SWIG_fail;
27865     }
27866     {
27867         resultobj = SWIG_From_int((int)(result));
27868     }
27869     return resultobj;
27870     fail:
27871     return NULL;
27872 }
27873
27874
27875 static PyObject *_wrap_TreeEvent_SetKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
27876     PyObject *resultobj;
27877     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27878     wxKeyEvent *arg2 = 0 ;
27879     PyObject * obj0 = 0 ;
27880     PyObject * obj1 = 0 ;
27881     char *kwnames[] = {
27882         (char *) "self",(char *) "evt", NULL
27883     };
27884
27885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetKeyEvent",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
27890         if (SWIG_arg_fail(2)) SWIG_fail;
27891         if (arg2 == NULL) {
27892             SWIG_null_ref("wxKeyEvent");
27893         }
27894         if (SWIG_arg_fail(2)) SWIG_fail;
27895     }
27896     {
27897         PyThreadState* __tstate = wxPyBeginAllowThreads();
27898         (arg1)->SetKeyEvent((wxKeyEvent const &)*arg2);
27899
27900         wxPyEndAllowThreads(__tstate);
27901         if (PyErr_Occurred()) SWIG_fail;
27902     }
27903     Py_INCREF(Py_None); resultobj = Py_None;
27904     return resultobj;
27905     fail:
27906     return NULL;
27907 }
27908
27909
27910 static PyObject *_wrap_TreeEvent_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
27911     PyObject *resultobj;
27912     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27913     wxString *result;
27914     PyObject * obj0 = 0 ;
27915     char *kwnames[] = {
27916         (char *) "self", NULL
27917     };
27918
27919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_GetLabel",kwnames,&obj0)) goto fail;
27920     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27921     if (SWIG_arg_fail(1)) SWIG_fail;
27922     {
27923         PyThreadState* __tstate = wxPyBeginAllowThreads();
27924         {
27925             wxString const &_result_ref = ((wxTreeEvent const *)arg1)->GetLabel();
27926             result = (wxString *) &_result_ref;
27927         }
27928
27929         wxPyEndAllowThreads(__tstate);
27930         if (PyErr_Occurred()) SWIG_fail;
27931     }
27932     {
27933 #if wxUSE_UNICODE
27934         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27935 #else
27936         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27937 #endif
27938     }
27939     return resultobj;
27940     fail:
27941     return NULL;
27942 }
27943
27944
27945 static PyObject *_wrap_TreeEvent_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
27946     PyObject *resultobj;
27947     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27948     wxString *arg2 = 0 ;
27949     bool temp2 = false ;
27950     PyObject * obj0 = 0 ;
27951     PyObject * obj1 = 0 ;
27952     char *kwnames[] = {
27953         (char *) "self",(char *) "label", NULL
27954     };
27955
27956     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetLabel",kwnames,&obj0,&obj1)) goto fail;
27957     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27958     if (SWIG_arg_fail(1)) SWIG_fail;
27959     {
27960         arg2 = wxString_in_helper(obj1);
27961         if (arg2 == NULL) SWIG_fail;
27962         temp2 = true;
27963     }
27964     {
27965         PyThreadState* __tstate = wxPyBeginAllowThreads();
27966         (arg1)->SetLabel((wxString const &)*arg2);
27967
27968         wxPyEndAllowThreads(__tstate);
27969         if (PyErr_Occurred()) SWIG_fail;
27970     }
27971     Py_INCREF(Py_None); resultobj = Py_None;
27972     {
27973         if (temp2)
27974         delete arg2;
27975     }
27976     return resultobj;
27977     fail:
27978     {
27979         if (temp2)
27980         delete arg2;
27981     }
27982     return NULL;
27983 }
27984
27985
27986 static PyObject *_wrap_TreeEvent_IsEditCancelled(PyObject *, PyObject *args, PyObject *kwargs) {
27987     PyObject *resultobj;
27988     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
27989     bool result;
27990     PyObject * obj0 = 0 ;
27991     char *kwnames[] = {
27992         (char *) "self", NULL
27993     };
27994
27995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeEvent_IsEditCancelled",kwnames,&obj0)) goto fail;
27996     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
27997     if (SWIG_arg_fail(1)) SWIG_fail;
27998     {
27999         PyThreadState* __tstate = wxPyBeginAllowThreads();
28000         result = (bool)((wxTreeEvent const *)arg1)->IsEditCancelled();
28001
28002         wxPyEndAllowThreads(__tstate);
28003         if (PyErr_Occurred()) SWIG_fail;
28004     }
28005     {
28006         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28007     }
28008     return resultobj;
28009     fail:
28010     return NULL;
28011 }
28012
28013
28014 static PyObject *_wrap_TreeEvent_SetEditCanceled(PyObject *, PyObject *args, PyObject *kwargs) {
28015     PyObject *resultobj;
28016     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
28017     bool arg2 ;
28018     PyObject * obj0 = 0 ;
28019     PyObject * obj1 = 0 ;
28020     char *kwnames[] = {
28021         (char *) "self",(char *) "editCancelled", NULL
28022     };
28023
28024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetEditCanceled",kwnames,&obj0,&obj1)) goto fail;
28025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
28026     if (SWIG_arg_fail(1)) SWIG_fail;
28027     {
28028         arg2 = (bool)(SWIG_As_bool(obj1));
28029         if (SWIG_arg_fail(2)) SWIG_fail;
28030     }
28031     {
28032         PyThreadState* __tstate = wxPyBeginAllowThreads();
28033         (arg1)->SetEditCanceled(arg2);
28034
28035         wxPyEndAllowThreads(__tstate);
28036         if (PyErr_Occurred()) SWIG_fail;
28037     }
28038     Py_INCREF(Py_None); resultobj = Py_None;
28039     return resultobj;
28040     fail:
28041     return NULL;
28042 }
28043
28044
28045 static PyObject *_wrap_TreeEvent_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
28046     PyObject *resultobj;
28047     wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
28048     wxString *arg2 = 0 ;
28049     bool temp2 = false ;
28050     PyObject * obj0 = 0 ;
28051     PyObject * obj1 = 0 ;
28052     char *kwnames[] = {
28053         (char *) "self",(char *) "toolTip", NULL
28054     };
28055
28056     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
28057     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_EXCEPTION | 0);
28058     if (SWIG_arg_fail(1)) SWIG_fail;
28059     {
28060         arg2 = wxString_in_helper(obj1);
28061         if (arg2 == NULL) SWIG_fail;
28062         temp2 = true;
28063     }
28064     {
28065         PyThreadState* __tstate = wxPyBeginAllowThreads();
28066         (arg1)->SetToolTip((wxString const &)*arg2);
28067
28068         wxPyEndAllowThreads(__tstate);
28069         if (PyErr_Occurred()) SWIG_fail;
28070     }
28071     Py_INCREF(Py_None); resultobj = Py_None;
28072     {
28073         if (temp2)
28074         delete arg2;
28075     }
28076     return resultobj;
28077     fail:
28078     {
28079         if (temp2)
28080         delete arg2;
28081     }
28082     return NULL;
28083 }
28084
28085
28086 static PyObject * TreeEvent_swigregister(PyObject *, PyObject *args) {
28087     PyObject *obj;
28088     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28089     SWIG_TypeClientData(SWIGTYPE_p_wxTreeEvent, obj);
28090     Py_INCREF(obj);
28091     return Py_BuildValue((char *)"");
28092 }
28093 static PyObject *_wrap_new_TreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
28094     PyObject *resultobj;
28095     wxWindow *arg1 = (wxWindow *) 0 ;
28096     int arg2 = (int) -1 ;
28097     wxPoint const &arg3_defvalue = wxDefaultPosition ;
28098     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
28099     wxSize const &arg4_defvalue = wxDefaultSize ;
28100     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
28101     long arg5 = (long) wxTR_DEFAULT_STYLE ;
28102     wxValidator const &arg6_defvalue = wxDefaultValidator ;
28103     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
28104     wxString const &arg7_defvalue = wxPyTreeCtrlNameStr ;
28105     wxString *arg7 = (wxString *) &arg7_defvalue ;
28106     wxPyTreeCtrl *result;
28107     wxPoint temp3 ;
28108     wxSize temp4 ;
28109     bool temp7 = false ;
28110     PyObject * obj0 = 0 ;
28111     PyObject * obj1 = 0 ;
28112     PyObject * obj2 = 0 ;
28113     PyObject * obj3 = 0 ;
28114     PyObject * obj4 = 0 ;
28115     PyObject * obj5 = 0 ;
28116     PyObject * obj6 = 0 ;
28117     char *kwnames[] = {
28118         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
28119     };
28120
28121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_TreeCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
28122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123     if (SWIG_arg_fail(1)) SWIG_fail;
28124     if (obj1) {
28125         {
28126             arg2 = (int)(SWIG_As_int(obj1));
28127             if (SWIG_arg_fail(2)) SWIG_fail;
28128         }
28129     }
28130     if (obj2) {
28131         {
28132             arg3 = &temp3;
28133             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28134         }
28135     }
28136     if (obj3) {
28137         {
28138             arg4 = &temp4;
28139             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
28140         }
28141     }
28142     if (obj4) {
28143         {
28144             arg5 = (long)(SWIG_As_long(obj4));
28145             if (SWIG_arg_fail(5)) SWIG_fail;
28146         }
28147     }
28148     if (obj5) {
28149         {
28150             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28151             if (SWIG_arg_fail(6)) SWIG_fail;
28152             if (arg6 == NULL) {
28153                 SWIG_null_ref("wxValidator");
28154             }
28155             if (SWIG_arg_fail(6)) SWIG_fail;
28156         }
28157     }
28158     if (obj6) {
28159         {
28160             arg7 = wxString_in_helper(obj6);
28161             if (arg7 == NULL) SWIG_fail;
28162             temp7 = true;
28163         }
28164     }
28165     {
28166         if (!wxPyCheckForApp()) SWIG_fail;
28167         PyThreadState* __tstate = wxPyBeginAllowThreads();
28168         result = (wxPyTreeCtrl *)new wxPyTreeCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
28169
28170         wxPyEndAllowThreads(__tstate);
28171         if (PyErr_Occurred()) SWIG_fail;
28172     }
28173     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeCtrl, 1);
28174     {
28175         if (temp7)
28176         delete arg7;
28177     }
28178     return resultobj;
28179     fail:
28180     {
28181         if (temp7)
28182         delete arg7;
28183     }
28184     return NULL;
28185 }
28186
28187
28188 static PyObject *_wrap_new_PreTreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
28189     PyObject *resultobj;
28190     wxPyTreeCtrl *result;
28191     char *kwnames[] = {
28192         NULL
28193     };
28194
28195     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreTreeCtrl",kwnames)) goto fail;
28196     {
28197         if (!wxPyCheckForApp()) SWIG_fail;
28198         PyThreadState* __tstate = wxPyBeginAllowThreads();
28199         result = (wxPyTreeCtrl *)new wxPyTreeCtrl();
28200
28201         wxPyEndAllowThreads(__tstate);
28202         if (PyErr_Occurred()) SWIG_fail;
28203     }
28204     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeCtrl, 1);
28205     return resultobj;
28206     fail:
28207     return NULL;
28208 }
28209
28210
28211 static PyObject *_wrap_TreeCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
28212     PyObject *resultobj;
28213     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28214     wxWindow *arg2 = (wxWindow *) 0 ;
28215     int arg3 = (int) -1 ;
28216     wxPoint const &arg4_defvalue = wxDefaultPosition ;
28217     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
28218     wxSize const &arg5_defvalue = wxDefaultSize ;
28219     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
28220     long arg6 = (long) wxTR_DEFAULT_STYLE ;
28221     wxValidator const &arg7_defvalue = wxDefaultValidator ;
28222     wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
28223     wxString const &arg8_defvalue = wxPyTreeCtrlNameStr ;
28224     wxString *arg8 = (wxString *) &arg8_defvalue ;
28225     bool result;
28226     wxPoint temp4 ;
28227     wxSize temp5 ;
28228     bool temp8 = false ;
28229     PyObject * obj0 = 0 ;
28230     PyObject * obj1 = 0 ;
28231     PyObject * obj2 = 0 ;
28232     PyObject * obj3 = 0 ;
28233     PyObject * obj4 = 0 ;
28234     PyObject * obj5 = 0 ;
28235     PyObject * obj6 = 0 ;
28236     PyObject * obj7 = 0 ;
28237     char *kwnames[] = {
28238         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
28239     };
28240
28241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:TreeCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
28242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28243     if (SWIG_arg_fail(1)) SWIG_fail;
28244     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28245     if (SWIG_arg_fail(2)) SWIG_fail;
28246     if (obj2) {
28247         {
28248             arg3 = (int)(SWIG_As_int(obj2));
28249             if (SWIG_arg_fail(3)) SWIG_fail;
28250         }
28251     }
28252     if (obj3) {
28253         {
28254             arg4 = &temp4;
28255             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
28256         }
28257     }
28258     if (obj4) {
28259         {
28260             arg5 = &temp5;
28261             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
28262         }
28263     }
28264     if (obj5) {
28265         {
28266             arg6 = (long)(SWIG_As_long(obj5));
28267             if (SWIG_arg_fail(6)) SWIG_fail;
28268         }
28269     }
28270     if (obj6) {
28271         {
28272             SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28273             if (SWIG_arg_fail(7)) SWIG_fail;
28274             if (arg7 == NULL) {
28275                 SWIG_null_ref("wxValidator");
28276             }
28277             if (SWIG_arg_fail(7)) SWIG_fail;
28278         }
28279     }
28280     if (obj7) {
28281         {
28282             arg8 = wxString_in_helper(obj7);
28283             if (arg8 == NULL) SWIG_fail;
28284             temp8 = true;
28285         }
28286     }
28287     {
28288         PyThreadState* __tstate = wxPyBeginAllowThreads();
28289         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
28290
28291         wxPyEndAllowThreads(__tstate);
28292         if (PyErr_Occurred()) SWIG_fail;
28293     }
28294     {
28295         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28296     }
28297     {
28298         if (temp8)
28299         delete arg8;
28300     }
28301     return resultobj;
28302     fail:
28303     {
28304         if (temp8)
28305         delete arg8;
28306     }
28307     return NULL;
28308 }
28309
28310
28311 static PyObject *_wrap_TreeCtrl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28312     PyObject *resultobj;
28313     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28314     PyObject *arg2 = (PyObject *) 0 ;
28315     PyObject *arg3 = (PyObject *) 0 ;
28316     PyObject * obj0 = 0 ;
28317     PyObject * obj1 = 0 ;
28318     PyObject * obj2 = 0 ;
28319     char *kwnames[] = {
28320         (char *) "self",(char *) "self",(char *) "_class", NULL
28321     };
28322
28323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28325     if (SWIG_arg_fail(1)) SWIG_fail;
28326     arg2 = obj1;
28327     arg3 = obj2;
28328     {
28329         PyThreadState* __tstate = wxPyBeginAllowThreads();
28330         (arg1)->_setCallbackInfo(arg2,arg3);
28331
28332         wxPyEndAllowThreads(__tstate);
28333         if (PyErr_Occurred()) SWIG_fail;
28334     }
28335     Py_INCREF(Py_None); resultobj = Py_None;
28336     return resultobj;
28337     fail:
28338     return NULL;
28339 }
28340
28341
28342 static PyObject *_wrap_TreeCtrl_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
28343     PyObject *resultobj;
28344     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28345     size_t result;
28346     PyObject * obj0 = 0 ;
28347     char *kwnames[] = {
28348         (char *) "self", NULL
28349     };
28350
28351     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetCount",kwnames,&obj0)) goto fail;
28352     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28353     if (SWIG_arg_fail(1)) SWIG_fail;
28354     {
28355         PyThreadState* __tstate = wxPyBeginAllowThreads();
28356         result = (size_t)((wxPyTreeCtrl const *)arg1)->GetCount();
28357
28358         wxPyEndAllowThreads(__tstate);
28359         if (PyErr_Occurred()) SWIG_fail;
28360     }
28361     {
28362         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28363     }
28364     return resultobj;
28365     fail:
28366     return NULL;
28367 }
28368
28369
28370 static PyObject *_wrap_TreeCtrl_GetIndent(PyObject *, PyObject *args, PyObject *kwargs) {
28371     PyObject *resultobj;
28372     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28373     unsigned int result;
28374     PyObject * obj0 = 0 ;
28375     char *kwnames[] = {
28376         (char *) "self", NULL
28377     };
28378
28379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetIndent",kwnames,&obj0)) goto fail;
28380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28381     if (SWIG_arg_fail(1)) SWIG_fail;
28382     {
28383         PyThreadState* __tstate = wxPyBeginAllowThreads();
28384         result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetIndent();
28385
28386         wxPyEndAllowThreads(__tstate);
28387         if (PyErr_Occurred()) SWIG_fail;
28388     }
28389     {
28390         resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
28391     }
28392     return resultobj;
28393     fail:
28394     return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_TreeCtrl_SetIndent(PyObject *, PyObject *args, PyObject *kwargs) {
28399     PyObject *resultobj;
28400     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28401     unsigned int arg2 ;
28402     PyObject * obj0 = 0 ;
28403     PyObject * obj1 = 0 ;
28404     char *kwnames[] = {
28405         (char *) "self",(char *) "indent", NULL
28406     };
28407
28408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetIndent",kwnames,&obj0,&obj1)) goto fail;
28409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28410     if (SWIG_arg_fail(1)) SWIG_fail;
28411     {
28412         arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
28413         if (SWIG_arg_fail(2)) SWIG_fail;
28414     }
28415     {
28416         PyThreadState* __tstate = wxPyBeginAllowThreads();
28417         (arg1)->SetIndent(arg2);
28418
28419         wxPyEndAllowThreads(__tstate);
28420         if (PyErr_Occurred()) SWIG_fail;
28421     }
28422     Py_INCREF(Py_None); resultobj = Py_None;
28423     return resultobj;
28424     fail:
28425     return NULL;
28426 }
28427
28428
28429 static PyObject *_wrap_TreeCtrl_GetSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
28430     PyObject *resultobj;
28431     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28432     unsigned int result;
28433     PyObject * obj0 = 0 ;
28434     char *kwnames[] = {
28435         (char *) "self", NULL
28436     };
28437
28438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSpacing",kwnames,&obj0)) goto fail;
28439     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28440     if (SWIG_arg_fail(1)) SWIG_fail;
28441     {
28442         PyThreadState* __tstate = wxPyBeginAllowThreads();
28443         result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetSpacing();
28444
28445         wxPyEndAllowThreads(__tstate);
28446         if (PyErr_Occurred()) SWIG_fail;
28447     }
28448     {
28449         resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
28450     }
28451     return resultobj;
28452     fail:
28453     return NULL;
28454 }
28455
28456
28457 static PyObject *_wrap_TreeCtrl_SetSpacing(PyObject *, PyObject *args, PyObject *kwargs) {
28458     PyObject *resultobj;
28459     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28460     unsigned int arg2 ;
28461     PyObject * obj0 = 0 ;
28462     PyObject * obj1 = 0 ;
28463     char *kwnames[] = {
28464         (char *) "self",(char *) "spacing", NULL
28465     };
28466
28467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetSpacing",kwnames,&obj0,&obj1)) goto fail;
28468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28469     if (SWIG_arg_fail(1)) SWIG_fail;
28470     {
28471         arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
28472         if (SWIG_arg_fail(2)) SWIG_fail;
28473     }
28474     {
28475         PyThreadState* __tstate = wxPyBeginAllowThreads();
28476         (arg1)->SetSpacing(arg2);
28477
28478         wxPyEndAllowThreads(__tstate);
28479         if (PyErr_Occurred()) SWIG_fail;
28480     }
28481     Py_INCREF(Py_None); resultobj = Py_None;
28482     return resultobj;
28483     fail:
28484     return NULL;
28485 }
28486
28487
28488 static PyObject *_wrap_TreeCtrl_GetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28489     PyObject *resultobj;
28490     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28491     wxImageList *result;
28492     PyObject * obj0 = 0 ;
28493     char *kwnames[] = {
28494         (char *) "self", NULL
28495     };
28496
28497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetImageList",kwnames,&obj0)) goto fail;
28498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28499     if (SWIG_arg_fail(1)) SWIG_fail;
28500     {
28501         PyThreadState* __tstate = wxPyBeginAllowThreads();
28502         result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetImageList();
28503
28504         wxPyEndAllowThreads(__tstate);
28505         if (PyErr_Occurred()) SWIG_fail;
28506     }
28507     {
28508         resultobj = wxPyMake_wxObject(result, 0);
28509     }
28510     return resultobj;
28511     fail:
28512     return NULL;
28513 }
28514
28515
28516 static PyObject *_wrap_TreeCtrl_GetStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28517     PyObject *resultobj;
28518     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28519     wxImageList *result;
28520     PyObject * obj0 = 0 ;
28521     char *kwnames[] = {
28522         (char *) "self", NULL
28523     };
28524
28525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetStateImageList",kwnames,&obj0)) goto fail;
28526     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28527     if (SWIG_arg_fail(1)) SWIG_fail;
28528     {
28529         PyThreadState* __tstate = wxPyBeginAllowThreads();
28530         result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetStateImageList();
28531
28532         wxPyEndAllowThreads(__tstate);
28533         if (PyErr_Occurred()) SWIG_fail;
28534     }
28535     {
28536         resultobj = wxPyMake_wxObject(result, 0);
28537     }
28538     return resultobj;
28539     fail:
28540     return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_TreeCtrl_SetImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28545     PyObject *resultobj;
28546     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28547     wxImageList *arg2 = (wxImageList *) 0 ;
28548     PyObject * obj0 = 0 ;
28549     PyObject * obj1 = 0 ;
28550     char *kwnames[] = {
28551         (char *) "self",(char *) "imageList", NULL
28552     };
28553
28554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetImageList",kwnames,&obj0,&obj1)) goto fail;
28555     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28556     if (SWIG_arg_fail(1)) SWIG_fail;
28557     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
28558     if (SWIG_arg_fail(2)) SWIG_fail;
28559     {
28560         PyThreadState* __tstate = wxPyBeginAllowThreads();
28561         (arg1)->SetImageList(arg2);
28562
28563         wxPyEndAllowThreads(__tstate);
28564         if (PyErr_Occurred()) SWIG_fail;
28565     }
28566     Py_INCREF(Py_None); resultobj = Py_None;
28567     return resultobj;
28568     fail:
28569     return NULL;
28570 }
28571
28572
28573 static PyObject *_wrap_TreeCtrl_SetStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28574     PyObject *resultobj;
28575     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28576     wxImageList *arg2 = (wxImageList *) 0 ;
28577     PyObject * obj0 = 0 ;
28578     PyObject * obj1 = 0 ;
28579     char *kwnames[] = {
28580         (char *) "self",(char *) "imageList", NULL
28581     };
28582
28583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetStateImageList",kwnames,&obj0,&obj1)) goto fail;
28584     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28585     if (SWIG_arg_fail(1)) SWIG_fail;
28586     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
28587     if (SWIG_arg_fail(2)) SWIG_fail;
28588     {
28589         PyThreadState* __tstate = wxPyBeginAllowThreads();
28590         (arg1)->SetStateImageList(arg2);
28591
28592         wxPyEndAllowThreads(__tstate);
28593         if (PyErr_Occurred()) SWIG_fail;
28594     }
28595     Py_INCREF(Py_None); resultobj = Py_None;
28596     return resultobj;
28597     fail:
28598     return NULL;
28599 }
28600
28601
28602 static PyObject *_wrap_TreeCtrl_AssignImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28603     PyObject *resultobj;
28604     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28605     wxImageList *arg2 = (wxImageList *) 0 ;
28606     PyObject * obj0 = 0 ;
28607     PyObject * obj1 = 0 ;
28608     char *kwnames[] = {
28609         (char *) "self",(char *) "imageList", NULL
28610     };
28611
28612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignImageList",kwnames,&obj0,&obj1)) goto fail;
28613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28614     if (SWIG_arg_fail(1)) SWIG_fail;
28615     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28616     if (SWIG_arg_fail(2)) SWIG_fail;
28617     {
28618         PyThreadState* __tstate = wxPyBeginAllowThreads();
28619         (arg1)->AssignImageList(arg2);
28620
28621         wxPyEndAllowThreads(__tstate);
28622         if (PyErr_Occurred()) SWIG_fail;
28623     }
28624     Py_INCREF(Py_None); resultobj = Py_None;
28625     return resultobj;
28626     fail:
28627     return NULL;
28628 }
28629
28630
28631 static PyObject *_wrap_TreeCtrl_AssignStateImageList(PyObject *, PyObject *args, PyObject *kwargs) {
28632     PyObject *resultobj;
28633     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28634     wxImageList *arg2 = (wxImageList *) 0 ;
28635     PyObject * obj0 = 0 ;
28636     PyObject * obj1 = 0 ;
28637     char *kwnames[] = {
28638         (char *) "self",(char *) "imageList", NULL
28639     };
28640
28641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignStateImageList",kwnames,&obj0,&obj1)) goto fail;
28642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28643     if (SWIG_arg_fail(1)) SWIG_fail;
28644     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28645     if (SWIG_arg_fail(2)) SWIG_fail;
28646     {
28647         PyThreadState* __tstate = wxPyBeginAllowThreads();
28648         (arg1)->AssignStateImageList(arg2);
28649
28650         wxPyEndAllowThreads(__tstate);
28651         if (PyErr_Occurred()) SWIG_fail;
28652     }
28653     Py_INCREF(Py_None); resultobj = Py_None;
28654     return resultobj;
28655     fail:
28656     return NULL;
28657 }
28658
28659
28660 static PyObject *_wrap_TreeCtrl_GetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
28661     PyObject *resultobj;
28662     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28663     wxTreeItemId *arg2 = 0 ;
28664     wxString result;
28665     PyObject * obj0 = 0 ;
28666     PyObject * obj1 = 0 ;
28667     char *kwnames[] = {
28668         (char *) "self",(char *) "item", NULL
28669     };
28670
28671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemText",kwnames,&obj0,&obj1)) goto fail;
28672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28673     if (SWIG_arg_fail(1)) SWIG_fail;
28674     {
28675         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28676         if (SWIG_arg_fail(2)) SWIG_fail;
28677         if (arg2 == NULL) {
28678             SWIG_null_ref("wxTreeItemId");
28679         }
28680         if (SWIG_arg_fail(2)) SWIG_fail;
28681     }
28682     {
28683         PyThreadState* __tstate = wxPyBeginAllowThreads();
28684         result = ((wxPyTreeCtrl const *)arg1)->GetItemText((wxTreeItemId const &)*arg2);
28685
28686         wxPyEndAllowThreads(__tstate);
28687         if (PyErr_Occurred()) SWIG_fail;
28688     }
28689     {
28690 #if wxUSE_UNICODE
28691         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28692 #else
28693         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28694 #endif
28695     }
28696     return resultobj;
28697     fail:
28698     return NULL;
28699 }
28700
28701
28702 static PyObject *_wrap_TreeCtrl_GetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
28703     PyObject *resultobj;
28704     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28705     wxTreeItemId *arg2 = 0 ;
28706     wxTreeItemIcon arg3 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
28707     int result;
28708     PyObject * obj0 = 0 ;
28709     PyObject * obj1 = 0 ;
28710     PyObject * obj2 = 0 ;
28711     char *kwnames[] = {
28712         (char *) "self",(char *) "item",(char *) "which", NULL
28713     };
28714
28715     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetItemImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
28716     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28717     if (SWIG_arg_fail(1)) SWIG_fail;
28718     {
28719         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28720         if (SWIG_arg_fail(2)) SWIG_fail;
28721         if (arg2 == NULL) {
28722             SWIG_null_ref("wxTreeItemId");
28723         }
28724         if (SWIG_arg_fail(2)) SWIG_fail;
28725     }
28726     if (obj2) {
28727         {
28728             arg3 = (wxTreeItemIcon)(SWIG_As_int(obj2));
28729             if (SWIG_arg_fail(3)) SWIG_fail;
28730         }
28731     }
28732     {
28733         PyThreadState* __tstate = wxPyBeginAllowThreads();
28734         result = (int)((wxPyTreeCtrl const *)arg1)->GetItemImage((wxTreeItemId const &)*arg2,(wxTreeItemIcon )arg3);
28735
28736         wxPyEndAllowThreads(__tstate);
28737         if (PyErr_Occurred()) SWIG_fail;
28738     }
28739     {
28740         resultobj = SWIG_From_int((int)(result));
28741     }
28742     return resultobj;
28743     fail:
28744     return NULL;
28745 }
28746
28747
28748 static PyObject *_wrap_TreeCtrl_GetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
28749     PyObject *resultobj;
28750     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28751     wxTreeItemId *arg2 = 0 ;
28752     wxPyTreeItemData *result;
28753     PyObject * obj0 = 0 ;
28754     PyObject * obj1 = 0 ;
28755     char *kwnames[] = {
28756         (char *) "self",(char *) "item", NULL
28757     };
28758
28759     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemData",kwnames,&obj0,&obj1)) goto fail;
28760     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28761     if (SWIG_arg_fail(1)) SWIG_fail;
28762     {
28763         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28764         if (SWIG_arg_fail(2)) SWIG_fail;
28765         if (arg2 == NULL) {
28766             SWIG_null_ref("wxTreeItemId");
28767         }
28768         if (SWIG_arg_fail(2)) SWIG_fail;
28769     }
28770     {
28771         PyThreadState* __tstate = wxPyBeginAllowThreads();
28772         result = (wxPyTreeItemData *)wxPyTreeCtrl_GetItemData(arg1,(wxTreeItemId const &)*arg2);
28773
28774         wxPyEndAllowThreads(__tstate);
28775         if (PyErr_Occurred()) SWIG_fail;
28776     }
28777     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTreeItemData, 0);
28778     return resultobj;
28779     fail:
28780     return NULL;
28781 }
28782
28783
28784 static PyObject *_wrap_TreeCtrl_GetItemPyData(PyObject *, PyObject *args, PyObject *kwargs) {
28785     PyObject *resultobj;
28786     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28787     wxTreeItemId *arg2 = 0 ;
28788     PyObject *result;
28789     PyObject * obj0 = 0 ;
28790     PyObject * obj1 = 0 ;
28791     char *kwnames[] = {
28792         (char *) "self",(char *) "item", NULL
28793     };
28794
28795     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemPyData",kwnames,&obj0,&obj1)) goto fail;
28796     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28797     if (SWIG_arg_fail(1)) SWIG_fail;
28798     {
28799         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28800         if (SWIG_arg_fail(2)) SWIG_fail;
28801         if (arg2 == NULL) {
28802             SWIG_null_ref("wxTreeItemId");
28803         }
28804         if (SWIG_arg_fail(2)) SWIG_fail;
28805     }
28806     {
28807         PyThreadState* __tstate = wxPyBeginAllowThreads();
28808         result = (PyObject *)wxPyTreeCtrl_GetItemPyData(arg1,(wxTreeItemId const &)*arg2);
28809
28810         wxPyEndAllowThreads(__tstate);
28811         if (PyErr_Occurred()) SWIG_fail;
28812     }
28813     resultobj = result;
28814     return resultobj;
28815     fail:
28816     return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_TreeCtrl_GetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
28821     PyObject *resultobj;
28822     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28823     wxTreeItemId *arg2 = 0 ;
28824     wxColour result;
28825     PyObject * obj0 = 0 ;
28826     PyObject * obj1 = 0 ;
28827     char *kwnames[] = {
28828         (char *) "self",(char *) "item", NULL
28829     };
28830
28831     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) goto fail;
28832     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28833     if (SWIG_arg_fail(1)) SWIG_fail;
28834     {
28835         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28836         if (SWIG_arg_fail(2)) SWIG_fail;
28837         if (arg2 == NULL) {
28838             SWIG_null_ref("wxTreeItemId");
28839         }
28840         if (SWIG_arg_fail(2)) SWIG_fail;
28841     }
28842     {
28843         PyThreadState* __tstate = wxPyBeginAllowThreads();
28844         result = ((wxPyTreeCtrl const *)arg1)->GetItemTextColour((wxTreeItemId const &)*arg2);
28845
28846         wxPyEndAllowThreads(__tstate);
28847         if (PyErr_Occurred()) SWIG_fail;
28848     }
28849     {
28850         wxColour * resultptr;
28851         resultptr = new wxColour((wxColour &)(result));
28852         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28853     }
28854     return resultobj;
28855     fail:
28856     return NULL;
28857 }
28858
28859
28860 static PyObject *_wrap_TreeCtrl_GetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28861     PyObject *resultobj;
28862     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28863     wxTreeItemId *arg2 = 0 ;
28864     wxColour result;
28865     PyObject * obj0 = 0 ;
28866     PyObject * obj1 = 0 ;
28867     char *kwnames[] = {
28868         (char *) "self",(char *) "item", NULL
28869     };
28870
28871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28873     if (SWIG_arg_fail(1)) SWIG_fail;
28874     {
28875         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28876         if (SWIG_arg_fail(2)) SWIG_fail;
28877         if (arg2 == NULL) {
28878             SWIG_null_ref("wxTreeItemId");
28879         }
28880         if (SWIG_arg_fail(2)) SWIG_fail;
28881     }
28882     {
28883         PyThreadState* __tstate = wxPyBeginAllowThreads();
28884         result = ((wxPyTreeCtrl const *)arg1)->GetItemBackgroundColour((wxTreeItemId const &)*arg2);
28885
28886         wxPyEndAllowThreads(__tstate);
28887         if (PyErr_Occurred()) SWIG_fail;
28888     }
28889     {
28890         wxColour * resultptr;
28891         resultptr = new wxColour((wxColour &)(result));
28892         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28893     }
28894     return resultobj;
28895     fail:
28896     return NULL;
28897 }
28898
28899
28900 static PyObject *_wrap_TreeCtrl_GetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
28901     PyObject *resultobj;
28902     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28903     wxTreeItemId *arg2 = 0 ;
28904     wxFont result;
28905     PyObject * obj0 = 0 ;
28906     PyObject * obj1 = 0 ;
28907     char *kwnames[] = {
28908         (char *) "self",(char *) "item", NULL
28909     };
28910
28911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemFont",kwnames,&obj0,&obj1)) goto fail;
28912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28913     if (SWIG_arg_fail(1)) SWIG_fail;
28914     {
28915         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28916         if (SWIG_arg_fail(2)) SWIG_fail;
28917         if (arg2 == NULL) {
28918             SWIG_null_ref("wxTreeItemId");
28919         }
28920         if (SWIG_arg_fail(2)) SWIG_fail;
28921     }
28922     {
28923         PyThreadState* __tstate = wxPyBeginAllowThreads();
28924         result = ((wxPyTreeCtrl const *)arg1)->GetItemFont((wxTreeItemId const &)*arg2);
28925
28926         wxPyEndAllowThreads(__tstate);
28927         if (PyErr_Occurred()) SWIG_fail;
28928     }
28929     {
28930         wxFont * resultptr;
28931         resultptr = new wxFont((wxFont &)(result));
28932         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
28933     }
28934     return resultobj;
28935     fail:
28936     return NULL;
28937 }
28938
28939
28940 static PyObject *_wrap_TreeCtrl_SetItemText(PyObject *, PyObject *args, PyObject *kwargs) {
28941     PyObject *resultobj;
28942     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28943     wxTreeItemId *arg2 = 0 ;
28944     wxString *arg3 = 0 ;
28945     bool temp3 = false ;
28946     PyObject * obj0 = 0 ;
28947     PyObject * obj1 = 0 ;
28948     PyObject * obj2 = 0 ;
28949     char *kwnames[] = {
28950         (char *) "self",(char *) "item",(char *) "text", NULL
28951     };
28952
28953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) goto fail;
28954     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
28955     if (SWIG_arg_fail(1)) SWIG_fail;
28956     {
28957         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
28958         if (SWIG_arg_fail(2)) SWIG_fail;
28959         if (arg2 == NULL) {
28960             SWIG_null_ref("wxTreeItemId");
28961         }
28962         if (SWIG_arg_fail(2)) SWIG_fail;
28963     }
28964     {
28965         arg3 = wxString_in_helper(obj2);
28966         if (arg3 == NULL) SWIG_fail;
28967         temp3 = true;
28968     }
28969     {
28970         PyThreadState* __tstate = wxPyBeginAllowThreads();
28971         (arg1)->SetItemText((wxTreeItemId const &)*arg2,(wxString const &)*arg3);
28972
28973         wxPyEndAllowThreads(__tstate);
28974         if (PyErr_Occurred()) SWIG_fail;
28975     }
28976     Py_INCREF(Py_None); resultobj = Py_None;
28977     {
28978         if (temp3)
28979         delete arg3;
28980     }
28981     return resultobj;
28982     fail:
28983     {
28984         if (temp3)
28985         delete arg3;
28986     }
28987     return NULL;
28988 }
28989
28990
28991 static PyObject *_wrap_TreeCtrl_SetItemImage(PyObject *, PyObject *args, PyObject *kwargs) {
28992     PyObject *resultobj;
28993     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
28994     wxTreeItemId *arg2 = 0 ;
28995     int arg3 ;
28996     wxTreeItemIcon arg4 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
28997     PyObject * obj0 = 0 ;
28998     PyObject * obj1 = 0 ;
28999     PyObject * obj2 = 0 ;
29000     PyObject * obj3 = 0 ;
29001     char *kwnames[] = {
29002         (char *) "self",(char *) "item",(char *) "image",(char *) "which", NULL
29003     };
29004
29005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:TreeCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29007     if (SWIG_arg_fail(1)) SWIG_fail;
29008     {
29009         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29010         if (SWIG_arg_fail(2)) SWIG_fail;
29011         if (arg2 == NULL) {
29012             SWIG_null_ref("wxTreeItemId");
29013         }
29014         if (SWIG_arg_fail(2)) SWIG_fail;
29015     }
29016     {
29017         arg3 = (int)(SWIG_As_int(obj2));
29018         if (SWIG_arg_fail(3)) SWIG_fail;
29019     }
29020     if (obj3) {
29021         {
29022             arg4 = (wxTreeItemIcon)(SWIG_As_int(obj3));
29023             if (SWIG_arg_fail(4)) SWIG_fail;
29024         }
29025     }
29026     {
29027         PyThreadState* __tstate = wxPyBeginAllowThreads();
29028         (arg1)->SetItemImage((wxTreeItemId const &)*arg2,arg3,(wxTreeItemIcon )arg4);
29029
29030         wxPyEndAllowThreads(__tstate);
29031         if (PyErr_Occurred()) SWIG_fail;
29032     }
29033     Py_INCREF(Py_None); resultobj = Py_None;
29034     return resultobj;
29035     fail:
29036     return NULL;
29037 }
29038
29039
29040 static PyObject *_wrap_TreeCtrl_SetItemData(PyObject *, PyObject *args, PyObject *kwargs) {
29041     PyObject *resultobj;
29042     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29043     wxTreeItemId *arg2 = 0 ;
29044     wxPyTreeItemData *arg3 = (wxPyTreeItemData *) 0 ;
29045     PyObject * obj0 = 0 ;
29046     PyObject * obj1 = 0 ;
29047     PyObject * obj2 = 0 ;
29048     char *kwnames[] = {
29049         (char *) "self",(char *) "item",(char *) "data", NULL
29050     };
29051
29052     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) goto fail;
29053     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29054     if (SWIG_arg_fail(1)) SWIG_fail;
29055     {
29056         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29057         if (SWIG_arg_fail(2)) SWIG_fail;
29058         if (arg2 == NULL) {
29059             SWIG_null_ref("wxTreeItemId");
29060         }
29061         if (SWIG_arg_fail(2)) SWIG_fail;
29062     }
29063     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
29064     if (SWIG_arg_fail(3)) SWIG_fail;
29065     {
29066         PyThreadState* __tstate = wxPyBeginAllowThreads();
29067         wxPyTreeCtrl_SetItemData(arg1,(wxTreeItemId const &)*arg2,arg3);
29068
29069         wxPyEndAllowThreads(__tstate);
29070         if (PyErr_Occurred()) SWIG_fail;
29071     }
29072     Py_INCREF(Py_None); resultobj = Py_None;
29073     return resultobj;
29074     fail:
29075     return NULL;
29076 }
29077
29078
29079 static PyObject *_wrap_TreeCtrl_SetItemPyData(PyObject *, PyObject *args, PyObject *kwargs) {
29080     PyObject *resultobj;
29081     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29082     wxTreeItemId *arg2 = 0 ;
29083     PyObject *arg3 = (PyObject *) 0 ;
29084     PyObject * obj0 = 0 ;
29085     PyObject * obj1 = 0 ;
29086     PyObject * obj2 = 0 ;
29087     char *kwnames[] = {
29088         (char *) "self",(char *) "item",(char *) "obj", NULL
29089     };
29090
29091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemPyData",kwnames,&obj0,&obj1,&obj2)) goto fail;
29092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29093     if (SWIG_arg_fail(1)) SWIG_fail;
29094     {
29095         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29096         if (SWIG_arg_fail(2)) SWIG_fail;
29097         if (arg2 == NULL) {
29098             SWIG_null_ref("wxTreeItemId");
29099         }
29100         if (SWIG_arg_fail(2)) SWIG_fail;
29101     }
29102     arg3 = obj2;
29103     {
29104         PyThreadState* __tstate = wxPyBeginAllowThreads();
29105         wxPyTreeCtrl_SetItemPyData(arg1,(wxTreeItemId const &)*arg2,arg3);
29106
29107         wxPyEndAllowThreads(__tstate);
29108         if (PyErr_Occurred()) SWIG_fail;
29109     }
29110     Py_INCREF(Py_None); resultobj = Py_None;
29111     return resultobj;
29112     fail:
29113     return NULL;
29114 }
29115
29116
29117 static PyObject *_wrap_TreeCtrl_SetItemHasChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29118     PyObject *resultobj;
29119     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29120     wxTreeItemId *arg2 = 0 ;
29121     bool arg3 = (bool) true ;
29122     PyObject * obj0 = 0 ;
29123     PyObject * obj1 = 0 ;
29124     PyObject * obj2 = 0 ;
29125     char *kwnames[] = {
29126         (char *) "self",(char *) "item",(char *) "has", NULL
29127     };
29128
29129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemHasChildren",kwnames,&obj0,&obj1,&obj2)) goto fail;
29130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29131     if (SWIG_arg_fail(1)) SWIG_fail;
29132     {
29133         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29134         if (SWIG_arg_fail(2)) SWIG_fail;
29135         if (arg2 == NULL) {
29136             SWIG_null_ref("wxTreeItemId");
29137         }
29138         if (SWIG_arg_fail(2)) SWIG_fail;
29139     }
29140     if (obj2) {
29141         {
29142             arg3 = (bool)(SWIG_As_bool(obj2));
29143             if (SWIG_arg_fail(3)) SWIG_fail;
29144         }
29145     }
29146     {
29147         PyThreadState* __tstate = wxPyBeginAllowThreads();
29148         (arg1)->SetItemHasChildren((wxTreeItemId const &)*arg2,arg3);
29149
29150         wxPyEndAllowThreads(__tstate);
29151         if (PyErr_Occurred()) SWIG_fail;
29152     }
29153     Py_INCREF(Py_None); resultobj = Py_None;
29154     return resultobj;
29155     fail:
29156     return NULL;
29157 }
29158
29159
29160 static PyObject *_wrap_TreeCtrl_SetItemBold(PyObject *, PyObject *args, PyObject *kwargs) {
29161     PyObject *resultobj;
29162     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29163     wxTreeItemId *arg2 = 0 ;
29164     bool arg3 = (bool) true ;
29165     PyObject * obj0 = 0 ;
29166     PyObject * obj1 = 0 ;
29167     PyObject * obj2 = 0 ;
29168     char *kwnames[] = {
29169         (char *) "self",(char *) "item",(char *) "bold", NULL
29170     };
29171
29172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemBold",kwnames,&obj0,&obj1,&obj2)) goto fail;
29173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29174     if (SWIG_arg_fail(1)) SWIG_fail;
29175     {
29176         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29177         if (SWIG_arg_fail(2)) SWIG_fail;
29178         if (arg2 == NULL) {
29179             SWIG_null_ref("wxTreeItemId");
29180         }
29181         if (SWIG_arg_fail(2)) SWIG_fail;
29182     }
29183     if (obj2) {
29184         {
29185             arg3 = (bool)(SWIG_As_bool(obj2));
29186             if (SWIG_arg_fail(3)) SWIG_fail;
29187         }
29188     }
29189     {
29190         PyThreadState* __tstate = wxPyBeginAllowThreads();
29191         (arg1)->SetItemBold((wxTreeItemId const &)*arg2,arg3);
29192
29193         wxPyEndAllowThreads(__tstate);
29194         if (PyErr_Occurred()) SWIG_fail;
29195     }
29196     Py_INCREF(Py_None); resultobj = Py_None;
29197     return resultobj;
29198     fail:
29199     return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_TreeCtrl_SetItemDropHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
29204     PyObject *resultobj;
29205     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29206     wxTreeItemId *arg2 = 0 ;
29207     bool arg3 = (bool) true ;
29208     PyObject * obj0 = 0 ;
29209     PyObject * obj1 = 0 ;
29210     PyObject * obj2 = 0 ;
29211     char *kwnames[] = {
29212         (char *) "self",(char *) "item",(char *) "highlight", NULL
29213     };
29214
29215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemDropHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
29216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29217     if (SWIG_arg_fail(1)) SWIG_fail;
29218     {
29219         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29220         if (SWIG_arg_fail(2)) SWIG_fail;
29221         if (arg2 == NULL) {
29222             SWIG_null_ref("wxTreeItemId");
29223         }
29224         if (SWIG_arg_fail(2)) SWIG_fail;
29225     }
29226     if (obj2) {
29227         {
29228             arg3 = (bool)(SWIG_As_bool(obj2));
29229             if (SWIG_arg_fail(3)) SWIG_fail;
29230         }
29231     }
29232     {
29233         PyThreadState* __tstate = wxPyBeginAllowThreads();
29234         (arg1)->SetItemDropHighlight((wxTreeItemId const &)*arg2,arg3);
29235
29236         wxPyEndAllowThreads(__tstate);
29237         if (PyErr_Occurred()) SWIG_fail;
29238     }
29239     Py_INCREF(Py_None); resultobj = Py_None;
29240     return resultobj;
29241     fail:
29242     return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_TreeCtrl_SetItemTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
29247     PyObject *resultobj;
29248     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29249     wxTreeItemId *arg2 = 0 ;
29250     wxColour *arg3 = 0 ;
29251     wxColour temp3 ;
29252     PyObject * obj0 = 0 ;
29253     PyObject * obj1 = 0 ;
29254     PyObject * obj2 = 0 ;
29255     char *kwnames[] = {
29256         (char *) "self",(char *) "item",(char *) "col", NULL
29257     };
29258
29259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
29260     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29261     if (SWIG_arg_fail(1)) SWIG_fail;
29262     {
29263         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29264         if (SWIG_arg_fail(2)) SWIG_fail;
29265         if (arg2 == NULL) {
29266             SWIG_null_ref("wxTreeItemId");
29267         }
29268         if (SWIG_arg_fail(2)) SWIG_fail;
29269     }
29270     {
29271         arg3 = &temp3;
29272         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
29273     }
29274     {
29275         PyThreadState* __tstate = wxPyBeginAllowThreads();
29276         (arg1)->SetItemTextColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
29277
29278         wxPyEndAllowThreads(__tstate);
29279         if (PyErr_Occurred()) SWIG_fail;
29280     }
29281     Py_INCREF(Py_None); resultobj = Py_None;
29282     return resultobj;
29283     fail:
29284     return NULL;
29285 }
29286
29287
29288 static PyObject *_wrap_TreeCtrl_SetItemBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29289     PyObject *resultobj;
29290     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29291     wxTreeItemId *arg2 = 0 ;
29292     wxColour *arg3 = 0 ;
29293     wxColour temp3 ;
29294     PyObject * obj0 = 0 ;
29295     PyObject * obj1 = 0 ;
29296     PyObject * obj2 = 0 ;
29297     char *kwnames[] = {
29298         (char *) "self",(char *) "item",(char *) "col", NULL
29299     };
29300
29301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
29302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29303     if (SWIG_arg_fail(1)) SWIG_fail;
29304     {
29305         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29306         if (SWIG_arg_fail(2)) SWIG_fail;
29307         if (arg2 == NULL) {
29308             SWIG_null_ref("wxTreeItemId");
29309         }
29310         if (SWIG_arg_fail(2)) SWIG_fail;
29311     }
29312     {
29313         arg3 = &temp3;
29314         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
29315     }
29316     {
29317         PyThreadState* __tstate = wxPyBeginAllowThreads();
29318         (arg1)->SetItemBackgroundColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
29319
29320         wxPyEndAllowThreads(__tstate);
29321         if (PyErr_Occurred()) SWIG_fail;
29322     }
29323     Py_INCREF(Py_None); resultobj = Py_None;
29324     return resultobj;
29325     fail:
29326     return NULL;
29327 }
29328
29329
29330 static PyObject *_wrap_TreeCtrl_SetItemFont(PyObject *, PyObject *args, PyObject *kwargs) {
29331     PyObject *resultobj;
29332     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29333     wxTreeItemId *arg2 = 0 ;
29334     wxFont *arg3 = 0 ;
29335     PyObject * obj0 = 0 ;
29336     PyObject * obj1 = 0 ;
29337     PyObject * obj2 = 0 ;
29338     char *kwnames[] = {
29339         (char *) "self",(char *) "item",(char *) "font", NULL
29340     };
29341
29342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
29343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29344     if (SWIG_arg_fail(1)) SWIG_fail;
29345     {
29346         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29347         if (SWIG_arg_fail(2)) SWIG_fail;
29348         if (arg2 == NULL) {
29349             SWIG_null_ref("wxTreeItemId");
29350         }
29351         if (SWIG_arg_fail(2)) SWIG_fail;
29352     }
29353     {
29354         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29355         if (SWIG_arg_fail(3)) SWIG_fail;
29356         if (arg3 == NULL) {
29357             SWIG_null_ref("wxFont");
29358         }
29359         if (SWIG_arg_fail(3)) SWIG_fail;
29360     }
29361     {
29362         PyThreadState* __tstate = wxPyBeginAllowThreads();
29363         (arg1)->SetItemFont((wxTreeItemId const &)*arg2,(wxFont const &)*arg3);
29364
29365         wxPyEndAllowThreads(__tstate);
29366         if (PyErr_Occurred()) SWIG_fail;
29367     }
29368     Py_INCREF(Py_None); resultobj = Py_None;
29369     return resultobj;
29370     fail:
29371     return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_TreeCtrl_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
29376     PyObject *resultobj;
29377     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29378     wxTreeItemId *arg2 = 0 ;
29379     bool result;
29380     PyObject * obj0 = 0 ;
29381     PyObject * obj1 = 0 ;
29382     char *kwnames[] = {
29383         (char *) "self",(char *) "item", NULL
29384     };
29385
29386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsVisible",kwnames,&obj0,&obj1)) goto fail;
29387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29388     if (SWIG_arg_fail(1)) SWIG_fail;
29389     {
29390         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29391         if (SWIG_arg_fail(2)) SWIG_fail;
29392         if (arg2 == NULL) {
29393             SWIG_null_ref("wxTreeItemId");
29394         }
29395         if (SWIG_arg_fail(2)) SWIG_fail;
29396     }
29397     {
29398         PyThreadState* __tstate = wxPyBeginAllowThreads();
29399         result = (bool)((wxPyTreeCtrl const *)arg1)->IsVisible((wxTreeItemId const &)*arg2);
29400
29401         wxPyEndAllowThreads(__tstate);
29402         if (PyErr_Occurred()) SWIG_fail;
29403     }
29404     {
29405         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29406     }
29407     return resultobj;
29408     fail:
29409     return NULL;
29410 }
29411
29412
29413 static PyObject *_wrap_TreeCtrl_ItemHasChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29414     PyObject *resultobj;
29415     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29416     wxTreeItemId *arg2 = 0 ;
29417     bool result;
29418     PyObject * obj0 = 0 ;
29419     PyObject * obj1 = 0 ;
29420     char *kwnames[] = {
29421         (char *) "self",(char *) "item", NULL
29422     };
29423
29424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ItemHasChildren",kwnames,&obj0,&obj1)) goto fail;
29425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29426     if (SWIG_arg_fail(1)) SWIG_fail;
29427     {
29428         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29429         if (SWIG_arg_fail(2)) SWIG_fail;
29430         if (arg2 == NULL) {
29431             SWIG_null_ref("wxTreeItemId");
29432         }
29433         if (SWIG_arg_fail(2)) SWIG_fail;
29434     }
29435     {
29436         PyThreadState* __tstate = wxPyBeginAllowThreads();
29437         result = (bool)((wxPyTreeCtrl const *)arg1)->ItemHasChildren((wxTreeItemId const &)*arg2);
29438
29439         wxPyEndAllowThreads(__tstate);
29440         if (PyErr_Occurred()) SWIG_fail;
29441     }
29442     {
29443         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29444     }
29445     return resultobj;
29446     fail:
29447     return NULL;
29448 }
29449
29450
29451 static PyObject *_wrap_TreeCtrl_IsExpanded(PyObject *, PyObject *args, PyObject *kwargs) {
29452     PyObject *resultobj;
29453     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29454     wxTreeItemId *arg2 = 0 ;
29455     bool result;
29456     PyObject * obj0 = 0 ;
29457     PyObject * obj1 = 0 ;
29458     char *kwnames[] = {
29459         (char *) "self",(char *) "item", NULL
29460     };
29461
29462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsExpanded",kwnames,&obj0,&obj1)) goto fail;
29463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29464     if (SWIG_arg_fail(1)) SWIG_fail;
29465     {
29466         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29467         if (SWIG_arg_fail(2)) SWIG_fail;
29468         if (arg2 == NULL) {
29469             SWIG_null_ref("wxTreeItemId");
29470         }
29471         if (SWIG_arg_fail(2)) SWIG_fail;
29472     }
29473     {
29474         PyThreadState* __tstate = wxPyBeginAllowThreads();
29475         result = (bool)((wxPyTreeCtrl const *)arg1)->IsExpanded((wxTreeItemId const &)*arg2);
29476
29477         wxPyEndAllowThreads(__tstate);
29478         if (PyErr_Occurred()) SWIG_fail;
29479     }
29480     {
29481         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29482     }
29483     return resultobj;
29484     fail:
29485     return NULL;
29486 }
29487
29488
29489 static PyObject *_wrap_TreeCtrl_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
29490     PyObject *resultobj;
29491     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29492     wxTreeItemId *arg2 = 0 ;
29493     bool result;
29494     PyObject * obj0 = 0 ;
29495     PyObject * obj1 = 0 ;
29496     char *kwnames[] = {
29497         (char *) "self",(char *) "item", NULL
29498     };
29499
29500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsSelected",kwnames,&obj0,&obj1)) goto fail;
29501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29502     if (SWIG_arg_fail(1)) SWIG_fail;
29503     {
29504         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29505         if (SWIG_arg_fail(2)) SWIG_fail;
29506         if (arg2 == NULL) {
29507             SWIG_null_ref("wxTreeItemId");
29508         }
29509         if (SWIG_arg_fail(2)) SWIG_fail;
29510     }
29511     {
29512         PyThreadState* __tstate = wxPyBeginAllowThreads();
29513         result = (bool)((wxPyTreeCtrl const *)arg1)->IsSelected((wxTreeItemId const &)*arg2);
29514
29515         wxPyEndAllowThreads(__tstate);
29516         if (PyErr_Occurred()) SWIG_fail;
29517     }
29518     {
29519         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29520     }
29521     return resultobj;
29522     fail:
29523     return NULL;
29524 }
29525
29526
29527 static PyObject *_wrap_TreeCtrl_IsBold(PyObject *, PyObject *args, PyObject *kwargs) {
29528     PyObject *resultobj;
29529     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29530     wxTreeItemId *arg2 = 0 ;
29531     bool result;
29532     PyObject * obj0 = 0 ;
29533     PyObject * obj1 = 0 ;
29534     char *kwnames[] = {
29535         (char *) "self",(char *) "item", NULL
29536     };
29537
29538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsBold",kwnames,&obj0,&obj1)) goto fail;
29539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29540     if (SWIG_arg_fail(1)) SWIG_fail;
29541     {
29542         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29543         if (SWIG_arg_fail(2)) SWIG_fail;
29544         if (arg2 == NULL) {
29545             SWIG_null_ref("wxTreeItemId");
29546         }
29547         if (SWIG_arg_fail(2)) SWIG_fail;
29548     }
29549     {
29550         PyThreadState* __tstate = wxPyBeginAllowThreads();
29551         result = (bool)((wxPyTreeCtrl const *)arg1)->IsBold((wxTreeItemId const &)*arg2);
29552
29553         wxPyEndAllowThreads(__tstate);
29554         if (PyErr_Occurred()) SWIG_fail;
29555     }
29556     {
29557         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29558     }
29559     return resultobj;
29560     fail:
29561     return NULL;
29562 }
29563
29564
29565 static PyObject *_wrap_TreeCtrl_GetChildrenCount(PyObject *, PyObject *args, PyObject *kwargs) {
29566     PyObject *resultobj;
29567     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29568     wxTreeItemId *arg2 = 0 ;
29569     bool arg3 = (bool) true ;
29570     size_t result;
29571     PyObject * obj0 = 0 ;
29572     PyObject * obj1 = 0 ;
29573     PyObject * obj2 = 0 ;
29574     char *kwnames[] = {
29575         (char *) "self",(char *) "item",(char *) "recursively", NULL
29576     };
29577
29578     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetChildrenCount",kwnames,&obj0,&obj1,&obj2)) goto fail;
29579     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29580     if (SWIG_arg_fail(1)) SWIG_fail;
29581     {
29582         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29583         if (SWIG_arg_fail(2)) SWIG_fail;
29584         if (arg2 == NULL) {
29585             SWIG_null_ref("wxTreeItemId");
29586         }
29587         if (SWIG_arg_fail(2)) SWIG_fail;
29588     }
29589     if (obj2) {
29590         {
29591             arg3 = (bool)(SWIG_As_bool(obj2));
29592             if (SWIG_arg_fail(3)) SWIG_fail;
29593         }
29594     }
29595     {
29596         PyThreadState* __tstate = wxPyBeginAllowThreads();
29597         result = (size_t)(arg1)->GetChildrenCount((wxTreeItemId const &)*arg2,arg3);
29598
29599         wxPyEndAllowThreads(__tstate);
29600         if (PyErr_Occurred()) SWIG_fail;
29601     }
29602     {
29603         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
29604     }
29605     return resultobj;
29606     fail:
29607     return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_TreeCtrl_GetRootItem(PyObject *, PyObject *args, PyObject *kwargs) {
29612     PyObject *resultobj;
29613     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29614     wxTreeItemId result;
29615     PyObject * obj0 = 0 ;
29616     char *kwnames[] = {
29617         (char *) "self", NULL
29618     };
29619
29620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetRootItem",kwnames,&obj0)) goto fail;
29621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29622     if (SWIG_arg_fail(1)) SWIG_fail;
29623     {
29624         PyThreadState* __tstate = wxPyBeginAllowThreads();
29625         result = ((wxPyTreeCtrl const *)arg1)->GetRootItem();
29626
29627         wxPyEndAllowThreads(__tstate);
29628         if (PyErr_Occurred()) SWIG_fail;
29629     }
29630     {
29631         wxTreeItemId * resultptr;
29632         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29633         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29634     }
29635     return resultobj;
29636     fail:
29637     return NULL;
29638 }
29639
29640
29641 static PyObject *_wrap_TreeCtrl_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
29642     PyObject *resultobj;
29643     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29644     wxTreeItemId result;
29645     PyObject * obj0 = 0 ;
29646     char *kwnames[] = {
29647         (char *) "self", NULL
29648     };
29649
29650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSelection",kwnames,&obj0)) goto fail;
29651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29652     if (SWIG_arg_fail(1)) SWIG_fail;
29653     {
29654         PyThreadState* __tstate = wxPyBeginAllowThreads();
29655         result = ((wxPyTreeCtrl const *)arg1)->GetSelection();
29656
29657         wxPyEndAllowThreads(__tstate);
29658         if (PyErr_Occurred()) SWIG_fail;
29659     }
29660     {
29661         wxTreeItemId * resultptr;
29662         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29663         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29664     }
29665     return resultobj;
29666     fail:
29667     return NULL;
29668 }
29669
29670
29671 static PyObject *_wrap_TreeCtrl_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
29672     PyObject *resultobj;
29673     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29674     PyObject *result;
29675     PyObject * obj0 = 0 ;
29676     char *kwnames[] = {
29677         (char *) "self", NULL
29678     };
29679
29680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetSelections",kwnames,&obj0)) goto fail;
29681     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29682     if (SWIG_arg_fail(1)) SWIG_fail;
29683     {
29684         PyThreadState* __tstate = wxPyBeginAllowThreads();
29685         result = (PyObject *)wxPyTreeCtrl_GetSelections(arg1);
29686
29687         wxPyEndAllowThreads(__tstate);
29688         if (PyErr_Occurred()) SWIG_fail;
29689     }
29690     resultobj = result;
29691     return resultobj;
29692     fail:
29693     return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_TreeCtrl_GetItemParent(PyObject *, PyObject *args, PyObject *kwargs) {
29698     PyObject *resultobj;
29699     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29700     wxTreeItemId *arg2 = 0 ;
29701     wxTreeItemId result;
29702     PyObject * obj0 = 0 ;
29703     PyObject * obj1 = 0 ;
29704     char *kwnames[] = {
29705         (char *) "self",(char *) "item", NULL
29706     };
29707
29708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemParent",kwnames,&obj0,&obj1)) goto fail;
29709     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29710     if (SWIG_arg_fail(1)) SWIG_fail;
29711     {
29712         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29713         if (SWIG_arg_fail(2)) SWIG_fail;
29714         if (arg2 == NULL) {
29715             SWIG_null_ref("wxTreeItemId");
29716         }
29717         if (SWIG_arg_fail(2)) SWIG_fail;
29718     }
29719     {
29720         PyThreadState* __tstate = wxPyBeginAllowThreads();
29721         result = ((wxPyTreeCtrl const *)arg1)->GetItemParent((wxTreeItemId const &)*arg2);
29722
29723         wxPyEndAllowThreads(__tstate);
29724         if (PyErr_Occurred()) SWIG_fail;
29725     }
29726     {
29727         wxTreeItemId * resultptr;
29728         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29729         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29730     }
29731     return resultobj;
29732     fail:
29733     return NULL;
29734 }
29735
29736
29737 static PyObject *_wrap_TreeCtrl_GetFirstChild(PyObject *, PyObject *args, PyObject *kwargs) {
29738     PyObject *resultobj;
29739     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29740     wxTreeItemId *arg2 = 0 ;
29741     PyObject *result;
29742     PyObject * obj0 = 0 ;
29743     PyObject * obj1 = 0 ;
29744     char *kwnames[] = {
29745         (char *) "self",(char *) "item", NULL
29746     };
29747
29748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetFirstChild",kwnames,&obj0,&obj1)) goto fail;
29749     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29750     if (SWIG_arg_fail(1)) SWIG_fail;
29751     {
29752         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29753         if (SWIG_arg_fail(2)) SWIG_fail;
29754         if (arg2 == NULL) {
29755             SWIG_null_ref("wxTreeItemId");
29756         }
29757         if (SWIG_arg_fail(2)) SWIG_fail;
29758     }
29759     {
29760         PyThreadState* __tstate = wxPyBeginAllowThreads();
29761         result = (PyObject *)wxPyTreeCtrl_GetFirstChild(arg1,(wxTreeItemId const &)*arg2);
29762
29763         wxPyEndAllowThreads(__tstate);
29764         if (PyErr_Occurred()) SWIG_fail;
29765     }
29766     resultobj = result;
29767     return resultobj;
29768     fail:
29769     return NULL;
29770 }
29771
29772
29773 static PyObject *_wrap_TreeCtrl_GetNextChild(PyObject *, PyObject *args, PyObject *kwargs) {
29774     PyObject *resultobj;
29775     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29776     wxTreeItemId *arg2 = 0 ;
29777     void *arg3 = (void *) 0 ;
29778     PyObject *result;
29779     PyObject * obj0 = 0 ;
29780     PyObject * obj1 = 0 ;
29781     PyObject * obj2 = 0 ;
29782     char *kwnames[] = {
29783         (char *) "self",(char *) "item",(char *) "cookie", NULL
29784     };
29785
29786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_GetNextChild",kwnames,&obj0,&obj1,&obj2)) goto fail;
29787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29788     if (SWIG_arg_fail(1)) SWIG_fail;
29789     {
29790         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29791         if (SWIG_arg_fail(2)) SWIG_fail;
29792         if (arg2 == NULL) {
29793             SWIG_null_ref("wxTreeItemId");
29794         }
29795         if (SWIG_arg_fail(2)) SWIG_fail;
29796     }
29797     {
29798         if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) {
29799             SWIG_arg_fail(3);SWIG_fail;
29800         }
29801     }
29802     {
29803         PyThreadState* __tstate = wxPyBeginAllowThreads();
29804         result = (PyObject *)wxPyTreeCtrl_GetNextChild(arg1,(wxTreeItemId const &)*arg2,arg3);
29805
29806         wxPyEndAllowThreads(__tstate);
29807         if (PyErr_Occurred()) SWIG_fail;
29808     }
29809     resultobj = result;
29810     return resultobj;
29811     fail:
29812     return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_TreeCtrl_GetLastChild(PyObject *, PyObject *args, PyObject *kwargs) {
29817     PyObject *resultobj;
29818     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29819     wxTreeItemId *arg2 = 0 ;
29820     wxTreeItemId result;
29821     PyObject * obj0 = 0 ;
29822     PyObject * obj1 = 0 ;
29823     char *kwnames[] = {
29824         (char *) "self",(char *) "item", NULL
29825     };
29826
29827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetLastChild",kwnames,&obj0,&obj1)) goto fail;
29828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29829     if (SWIG_arg_fail(1)) SWIG_fail;
29830     {
29831         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29832         if (SWIG_arg_fail(2)) SWIG_fail;
29833         if (arg2 == NULL) {
29834             SWIG_null_ref("wxTreeItemId");
29835         }
29836         if (SWIG_arg_fail(2)) SWIG_fail;
29837     }
29838     {
29839         PyThreadState* __tstate = wxPyBeginAllowThreads();
29840         result = ((wxPyTreeCtrl const *)arg1)->GetLastChild((wxTreeItemId const &)*arg2);
29841
29842         wxPyEndAllowThreads(__tstate);
29843         if (PyErr_Occurred()) SWIG_fail;
29844     }
29845     {
29846         wxTreeItemId * resultptr;
29847         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29848         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29849     }
29850     return resultobj;
29851     fail:
29852     return NULL;
29853 }
29854
29855
29856 static PyObject *_wrap_TreeCtrl_GetNextSibling(PyObject *, PyObject *args, PyObject *kwargs) {
29857     PyObject *resultobj;
29858     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29859     wxTreeItemId *arg2 = 0 ;
29860     wxTreeItemId result;
29861     PyObject * obj0 = 0 ;
29862     PyObject * obj1 = 0 ;
29863     char *kwnames[] = {
29864         (char *) "self",(char *) "item", NULL
29865     };
29866
29867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextSibling",kwnames,&obj0,&obj1)) goto fail;
29868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29869     if (SWIG_arg_fail(1)) SWIG_fail;
29870     {
29871         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29872         if (SWIG_arg_fail(2)) SWIG_fail;
29873         if (arg2 == NULL) {
29874             SWIG_null_ref("wxTreeItemId");
29875         }
29876         if (SWIG_arg_fail(2)) SWIG_fail;
29877     }
29878     {
29879         PyThreadState* __tstate = wxPyBeginAllowThreads();
29880         result = ((wxPyTreeCtrl const *)arg1)->GetNextSibling((wxTreeItemId const &)*arg2);
29881
29882         wxPyEndAllowThreads(__tstate);
29883         if (PyErr_Occurred()) SWIG_fail;
29884     }
29885     {
29886         wxTreeItemId * resultptr;
29887         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29888         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29889     }
29890     return resultobj;
29891     fail:
29892     return NULL;
29893 }
29894
29895
29896 static PyObject *_wrap_TreeCtrl_GetPrevSibling(PyObject *, PyObject *args, PyObject *kwargs) {
29897     PyObject *resultobj;
29898     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29899     wxTreeItemId *arg2 = 0 ;
29900     wxTreeItemId result;
29901     PyObject * obj0 = 0 ;
29902     PyObject * obj1 = 0 ;
29903     char *kwnames[] = {
29904         (char *) "self",(char *) "item", NULL
29905     };
29906
29907     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevSibling",kwnames,&obj0,&obj1)) goto fail;
29908     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29909     if (SWIG_arg_fail(1)) SWIG_fail;
29910     {
29911         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29912         if (SWIG_arg_fail(2)) SWIG_fail;
29913         if (arg2 == NULL) {
29914             SWIG_null_ref("wxTreeItemId");
29915         }
29916         if (SWIG_arg_fail(2)) SWIG_fail;
29917     }
29918     {
29919         PyThreadState* __tstate = wxPyBeginAllowThreads();
29920         result = ((wxPyTreeCtrl const *)arg1)->GetPrevSibling((wxTreeItemId const &)*arg2);
29921
29922         wxPyEndAllowThreads(__tstate);
29923         if (PyErr_Occurred()) SWIG_fail;
29924     }
29925     {
29926         wxTreeItemId * resultptr;
29927         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29928         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29929     }
29930     return resultobj;
29931     fail:
29932     return NULL;
29933 }
29934
29935
29936 static PyObject *_wrap_TreeCtrl_GetFirstVisibleItem(PyObject *, PyObject *args, PyObject *kwargs) {
29937     PyObject *resultobj;
29938     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29939     wxTreeItemId result;
29940     PyObject * obj0 = 0 ;
29941     char *kwnames[] = {
29942         (char *) "self", NULL
29943     };
29944
29945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetFirstVisibleItem",kwnames,&obj0)) goto fail;
29946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29947     if (SWIG_arg_fail(1)) SWIG_fail;
29948     {
29949         PyThreadState* __tstate = wxPyBeginAllowThreads();
29950         result = ((wxPyTreeCtrl const *)arg1)->GetFirstVisibleItem();
29951
29952         wxPyEndAllowThreads(__tstate);
29953         if (PyErr_Occurred()) SWIG_fail;
29954     }
29955     {
29956         wxTreeItemId * resultptr;
29957         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29958         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29959     }
29960     return resultobj;
29961     fail:
29962     return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_TreeCtrl_GetNextVisible(PyObject *, PyObject *args, PyObject *kwargs) {
29967     PyObject *resultobj;
29968     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
29969     wxTreeItemId *arg2 = 0 ;
29970     wxTreeItemId result;
29971     PyObject * obj0 = 0 ;
29972     PyObject * obj1 = 0 ;
29973     char *kwnames[] = {
29974         (char *) "self",(char *) "item", NULL
29975     };
29976
29977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextVisible",kwnames,&obj0,&obj1)) goto fail;
29978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
29979     if (SWIG_arg_fail(1)) SWIG_fail;
29980     {
29981         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
29982         if (SWIG_arg_fail(2)) SWIG_fail;
29983         if (arg2 == NULL) {
29984             SWIG_null_ref("wxTreeItemId");
29985         }
29986         if (SWIG_arg_fail(2)) SWIG_fail;
29987     }
29988     {
29989         PyThreadState* __tstate = wxPyBeginAllowThreads();
29990         result = ((wxPyTreeCtrl const *)arg1)->GetNextVisible((wxTreeItemId const &)*arg2);
29991
29992         wxPyEndAllowThreads(__tstate);
29993         if (PyErr_Occurred()) SWIG_fail;
29994     }
29995     {
29996         wxTreeItemId * resultptr;
29997         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
29998         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
29999     }
30000     return resultobj;
30001     fail:
30002     return NULL;
30003 }
30004
30005
30006 static PyObject *_wrap_TreeCtrl_GetPrevVisible(PyObject *, PyObject *args, PyObject *kwargs) {
30007     PyObject *resultobj;
30008     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30009     wxTreeItemId *arg2 = 0 ;
30010     wxTreeItemId result;
30011     PyObject * obj0 = 0 ;
30012     PyObject * obj1 = 0 ;
30013     char *kwnames[] = {
30014         (char *) "self",(char *) "item", NULL
30015     };
30016
30017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevVisible",kwnames,&obj0,&obj1)) goto fail;
30018     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30019     if (SWIG_arg_fail(1)) SWIG_fail;
30020     {
30021         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30022         if (SWIG_arg_fail(2)) SWIG_fail;
30023         if (arg2 == NULL) {
30024             SWIG_null_ref("wxTreeItemId");
30025         }
30026         if (SWIG_arg_fail(2)) SWIG_fail;
30027     }
30028     {
30029         PyThreadState* __tstate = wxPyBeginAllowThreads();
30030         result = ((wxPyTreeCtrl const *)arg1)->GetPrevVisible((wxTreeItemId const &)*arg2);
30031
30032         wxPyEndAllowThreads(__tstate);
30033         if (PyErr_Occurred()) SWIG_fail;
30034     }
30035     {
30036         wxTreeItemId * resultptr;
30037         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30038         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30039     }
30040     return resultobj;
30041     fail:
30042     return NULL;
30043 }
30044
30045
30046 static PyObject *_wrap_TreeCtrl_AddRoot(PyObject *, PyObject *args, PyObject *kwargs) {
30047     PyObject *resultobj;
30048     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30049     wxString *arg2 = 0 ;
30050     int arg3 = (int) -1 ;
30051     int arg4 = (int) -1 ;
30052     wxPyTreeItemData *arg5 = (wxPyTreeItemData *) NULL ;
30053     wxTreeItemId result;
30054     bool temp2 = false ;
30055     PyObject * obj0 = 0 ;
30056     PyObject * obj1 = 0 ;
30057     PyObject * obj2 = 0 ;
30058     PyObject * obj3 = 0 ;
30059     PyObject * obj4 = 0 ;
30060     char *kwnames[] = {
30061         (char *) "self",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30062     };
30063
30064     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:TreeCtrl_AddRoot",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30065     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30066     if (SWIG_arg_fail(1)) SWIG_fail;
30067     {
30068         arg2 = wxString_in_helper(obj1);
30069         if (arg2 == NULL) SWIG_fail;
30070         temp2 = true;
30071     }
30072     if (obj2) {
30073         {
30074             arg3 = (int)(SWIG_As_int(obj2));
30075             if (SWIG_arg_fail(3)) SWIG_fail;
30076         }
30077     }
30078     if (obj3) {
30079         {
30080             arg4 = (int)(SWIG_As_int(obj3));
30081             if (SWIG_arg_fail(4)) SWIG_fail;
30082         }
30083     }
30084     if (obj4) {
30085         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30086         if (SWIG_arg_fail(5)) SWIG_fail;
30087     }
30088     {
30089         PyThreadState* __tstate = wxPyBeginAllowThreads();
30090         result = (arg1)->AddRoot((wxString const &)*arg2,arg3,arg4,arg5);
30091
30092         wxPyEndAllowThreads(__tstate);
30093         if (PyErr_Occurred()) SWIG_fail;
30094     }
30095     {
30096         wxTreeItemId * resultptr;
30097         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30098         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30099     }
30100     {
30101         if (temp2)
30102         delete arg2;
30103     }
30104     return resultobj;
30105     fail:
30106     {
30107         if (temp2)
30108         delete arg2;
30109     }
30110     return NULL;
30111 }
30112
30113
30114 static PyObject *_wrap_TreeCtrl_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
30115     PyObject *resultobj;
30116     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30117     wxTreeItemId *arg2 = 0 ;
30118     wxString *arg3 = 0 ;
30119     int arg4 = (int) -1 ;
30120     int arg5 = (int) -1 ;
30121     wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
30122     wxTreeItemId result;
30123     bool temp3 = false ;
30124     PyObject * obj0 = 0 ;
30125     PyObject * obj1 = 0 ;
30126     PyObject * obj2 = 0 ;
30127     PyObject * obj3 = 0 ;
30128     PyObject * obj4 = 0 ;
30129     PyObject * obj5 = 0 ;
30130     char *kwnames[] = {
30131         (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30132     };
30133
30134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_PrependItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30136     if (SWIG_arg_fail(1)) SWIG_fail;
30137     {
30138         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30139         if (SWIG_arg_fail(2)) SWIG_fail;
30140         if (arg2 == NULL) {
30141             SWIG_null_ref("wxTreeItemId");
30142         }
30143         if (SWIG_arg_fail(2)) SWIG_fail;
30144     }
30145     {
30146         arg3 = wxString_in_helper(obj2);
30147         if (arg3 == NULL) SWIG_fail;
30148         temp3 = true;
30149     }
30150     if (obj3) {
30151         {
30152             arg4 = (int)(SWIG_As_int(obj3));
30153             if (SWIG_arg_fail(4)) SWIG_fail;
30154         }
30155     }
30156     if (obj4) {
30157         {
30158             arg5 = (int)(SWIG_As_int(obj4));
30159             if (SWIG_arg_fail(5)) SWIG_fail;
30160         }
30161     }
30162     if (obj5) {
30163         SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30164         if (SWIG_arg_fail(6)) SWIG_fail;
30165     }
30166     {
30167         PyThreadState* __tstate = wxPyBeginAllowThreads();
30168         result = (arg1)->PrependItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
30169
30170         wxPyEndAllowThreads(__tstate);
30171         if (PyErr_Occurred()) SWIG_fail;
30172     }
30173     {
30174         wxTreeItemId * resultptr;
30175         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30176         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30177     }
30178     {
30179         if (temp3)
30180         delete arg3;
30181     }
30182     return resultobj;
30183     fail:
30184     {
30185         if (temp3)
30186         delete arg3;
30187     }
30188     return NULL;
30189 }
30190
30191
30192 static PyObject *_wrap_TreeCtrl_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
30193     PyObject *resultobj;
30194     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30195     wxTreeItemId *arg2 = 0 ;
30196     wxTreeItemId *arg3 = 0 ;
30197     wxString *arg4 = 0 ;
30198     int arg5 = (int) -1 ;
30199     int arg6 = (int) -1 ;
30200     wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
30201     wxTreeItemId result;
30202     bool temp4 = false ;
30203     PyObject * obj0 = 0 ;
30204     PyObject * obj1 = 0 ;
30205     PyObject * obj2 = 0 ;
30206     PyObject * obj3 = 0 ;
30207     PyObject * obj4 = 0 ;
30208     PyObject * obj5 = 0 ;
30209     PyObject * obj6 = 0 ;
30210     char *kwnames[] = {
30211         (char *) "self",(char *) "parent",(char *) "idPrevious",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30212     };
30213
30214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
30215     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30216     if (SWIG_arg_fail(1)) SWIG_fail;
30217     {
30218         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30219         if (SWIG_arg_fail(2)) SWIG_fail;
30220         if (arg2 == NULL) {
30221             SWIG_null_ref("wxTreeItemId");
30222         }
30223         if (SWIG_arg_fail(2)) SWIG_fail;
30224     }
30225     {
30226         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30227         if (SWIG_arg_fail(3)) SWIG_fail;
30228         if (arg3 == NULL) {
30229             SWIG_null_ref("wxTreeItemId");
30230         }
30231         if (SWIG_arg_fail(3)) SWIG_fail;
30232     }
30233     {
30234         arg4 = wxString_in_helper(obj3);
30235         if (arg4 == NULL) SWIG_fail;
30236         temp4 = true;
30237     }
30238     if (obj4) {
30239         {
30240             arg5 = (int)(SWIG_As_int(obj4));
30241             if (SWIG_arg_fail(5)) SWIG_fail;
30242         }
30243     }
30244     if (obj5) {
30245         {
30246             arg6 = (int)(SWIG_As_int(obj5));
30247             if (SWIG_arg_fail(6)) SWIG_fail;
30248         }
30249     }
30250     if (obj6) {
30251         SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30252         if (SWIG_arg_fail(7)) SWIG_fail;
30253     }
30254     {
30255         PyThreadState* __tstate = wxPyBeginAllowThreads();
30256         result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,(wxTreeItemId const &)*arg3,(wxString const &)*arg4,arg5,arg6,arg7);
30257
30258         wxPyEndAllowThreads(__tstate);
30259         if (PyErr_Occurred()) SWIG_fail;
30260     }
30261     {
30262         wxTreeItemId * resultptr;
30263         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30264         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30265     }
30266     {
30267         if (temp4)
30268         delete arg4;
30269     }
30270     return resultobj;
30271     fail:
30272     {
30273         if (temp4)
30274         delete arg4;
30275     }
30276     return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_TreeCtrl_InsertItemBefore(PyObject *, PyObject *args, PyObject *kwargs) {
30281     PyObject *resultobj;
30282     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30283     wxTreeItemId *arg2 = 0 ;
30284     size_t arg3 ;
30285     wxString *arg4 = 0 ;
30286     int arg5 = (int) -1 ;
30287     int arg6 = (int) -1 ;
30288     wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
30289     wxTreeItemId result;
30290     bool temp4 = false ;
30291     PyObject * obj0 = 0 ;
30292     PyObject * obj1 = 0 ;
30293     PyObject * obj2 = 0 ;
30294     PyObject * obj3 = 0 ;
30295     PyObject * obj4 = 0 ;
30296     PyObject * obj5 = 0 ;
30297     PyObject * obj6 = 0 ;
30298     char *kwnames[] = {
30299         (char *) "self",(char *) "parent",(char *) "index",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30300     };
30301
30302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItemBefore",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
30303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30304     if (SWIG_arg_fail(1)) SWIG_fail;
30305     {
30306         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30307         if (SWIG_arg_fail(2)) SWIG_fail;
30308         if (arg2 == NULL) {
30309             SWIG_null_ref("wxTreeItemId");
30310         }
30311         if (SWIG_arg_fail(2)) SWIG_fail;
30312     }
30313     {
30314         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
30315         if (SWIG_arg_fail(3)) SWIG_fail;
30316     }
30317     {
30318         arg4 = wxString_in_helper(obj3);
30319         if (arg4 == NULL) SWIG_fail;
30320         temp4 = true;
30321     }
30322     if (obj4) {
30323         {
30324             arg5 = (int)(SWIG_As_int(obj4));
30325             if (SWIG_arg_fail(5)) SWIG_fail;
30326         }
30327     }
30328     if (obj5) {
30329         {
30330             arg6 = (int)(SWIG_As_int(obj5));
30331             if (SWIG_arg_fail(6)) SWIG_fail;
30332         }
30333     }
30334     if (obj6) {
30335         SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30336         if (SWIG_arg_fail(7)) SWIG_fail;
30337     }
30338     {
30339         PyThreadState* __tstate = wxPyBeginAllowThreads();
30340         result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,arg3,(wxString const &)*arg4,arg5,arg6,arg7);
30341
30342         wxPyEndAllowThreads(__tstate);
30343         if (PyErr_Occurred()) SWIG_fail;
30344     }
30345     {
30346         wxTreeItemId * resultptr;
30347         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30348         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30349     }
30350     {
30351         if (temp4)
30352         delete arg4;
30353     }
30354     return resultobj;
30355     fail:
30356     {
30357         if (temp4)
30358         delete arg4;
30359     }
30360     return NULL;
30361 }
30362
30363
30364 static PyObject *_wrap_TreeCtrl_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
30365     PyObject *resultobj;
30366     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30367     wxTreeItemId *arg2 = 0 ;
30368     wxString *arg3 = 0 ;
30369     int arg4 = (int) -1 ;
30370     int arg5 = (int) -1 ;
30371     wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
30372     wxTreeItemId result;
30373     bool temp3 = false ;
30374     PyObject * obj0 = 0 ;
30375     PyObject * obj1 = 0 ;
30376     PyObject * obj2 = 0 ;
30377     PyObject * obj3 = 0 ;
30378     PyObject * obj4 = 0 ;
30379     PyObject * obj5 = 0 ;
30380     char *kwnames[] = {
30381         (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL
30382     };
30383
30384     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_AppendItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30385     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30386     if (SWIG_arg_fail(1)) SWIG_fail;
30387     {
30388         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30389         if (SWIG_arg_fail(2)) SWIG_fail;
30390         if (arg2 == NULL) {
30391             SWIG_null_ref("wxTreeItemId");
30392         }
30393         if (SWIG_arg_fail(2)) SWIG_fail;
30394     }
30395     {
30396         arg3 = wxString_in_helper(obj2);
30397         if (arg3 == NULL) SWIG_fail;
30398         temp3 = true;
30399     }
30400     if (obj3) {
30401         {
30402             arg4 = (int)(SWIG_As_int(obj3));
30403             if (SWIG_arg_fail(4)) SWIG_fail;
30404         }
30405     }
30406     if (obj4) {
30407         {
30408             arg5 = (int)(SWIG_As_int(obj4));
30409             if (SWIG_arg_fail(5)) SWIG_fail;
30410         }
30411     }
30412     if (obj5) {
30413         SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_EXCEPTION | 0);
30414         if (SWIG_arg_fail(6)) SWIG_fail;
30415     }
30416     {
30417         PyThreadState* __tstate = wxPyBeginAllowThreads();
30418         result = (arg1)->AppendItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
30419
30420         wxPyEndAllowThreads(__tstate);
30421         if (PyErr_Occurred()) SWIG_fail;
30422     }
30423     {
30424         wxTreeItemId * resultptr;
30425         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
30426         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
30427     }
30428     {
30429         if (temp3)
30430         delete arg3;
30431     }
30432     return resultobj;
30433     fail:
30434     {
30435         if (temp3)
30436         delete arg3;
30437     }
30438     return NULL;
30439 }
30440
30441
30442 static PyObject *_wrap_TreeCtrl_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
30443     PyObject *resultobj;
30444     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30445     wxTreeItemId *arg2 = 0 ;
30446     PyObject * obj0 = 0 ;
30447     PyObject * obj1 = 0 ;
30448     char *kwnames[] = {
30449         (char *) "self",(char *) "item", NULL
30450     };
30451
30452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Delete",kwnames,&obj0,&obj1)) goto fail;
30453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30454     if (SWIG_arg_fail(1)) SWIG_fail;
30455     {
30456         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30457         if (SWIG_arg_fail(2)) SWIG_fail;
30458         if (arg2 == NULL) {
30459             SWIG_null_ref("wxTreeItemId");
30460         }
30461         if (SWIG_arg_fail(2)) SWIG_fail;
30462     }
30463     {
30464         PyThreadState* __tstate = wxPyBeginAllowThreads();
30465         (arg1)->Delete((wxTreeItemId const &)*arg2);
30466
30467         wxPyEndAllowThreads(__tstate);
30468         if (PyErr_Occurred()) SWIG_fail;
30469     }
30470     Py_INCREF(Py_None); resultobj = Py_None;
30471     return resultobj;
30472     fail:
30473     return NULL;
30474 }
30475
30476
30477 static PyObject *_wrap_TreeCtrl_DeleteChildren(PyObject *, PyObject *args, PyObject *kwargs) {
30478     PyObject *resultobj;
30479     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30480     wxTreeItemId *arg2 = 0 ;
30481     PyObject * obj0 = 0 ;
30482     PyObject * obj1 = 0 ;
30483     char *kwnames[] = {
30484         (char *) "self",(char *) "item", NULL
30485     };
30486
30487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_DeleteChildren",kwnames,&obj0,&obj1)) goto fail;
30488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30489     if (SWIG_arg_fail(1)) SWIG_fail;
30490     {
30491         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30492         if (SWIG_arg_fail(2)) SWIG_fail;
30493         if (arg2 == NULL) {
30494             SWIG_null_ref("wxTreeItemId");
30495         }
30496         if (SWIG_arg_fail(2)) SWIG_fail;
30497     }
30498     {
30499         PyThreadState* __tstate = wxPyBeginAllowThreads();
30500         (arg1)->DeleteChildren((wxTreeItemId const &)*arg2);
30501
30502         wxPyEndAllowThreads(__tstate);
30503         if (PyErr_Occurred()) SWIG_fail;
30504     }
30505     Py_INCREF(Py_None); resultobj = Py_None;
30506     return resultobj;
30507     fail:
30508     return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_TreeCtrl_DeleteAllItems(PyObject *, PyObject *args, PyObject *kwargs) {
30513     PyObject *resultobj;
30514     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30515     PyObject * obj0 = 0 ;
30516     char *kwnames[] = {
30517         (char *) "self", NULL
30518     };
30519
30520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_DeleteAllItems",kwnames,&obj0)) goto fail;
30521     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30522     if (SWIG_arg_fail(1)) SWIG_fail;
30523     {
30524         PyThreadState* __tstate = wxPyBeginAllowThreads();
30525         (arg1)->DeleteAllItems();
30526
30527         wxPyEndAllowThreads(__tstate);
30528         if (PyErr_Occurred()) SWIG_fail;
30529     }
30530     Py_INCREF(Py_None); resultobj = Py_None;
30531     return resultobj;
30532     fail:
30533     return NULL;
30534 }
30535
30536
30537 static PyObject *_wrap_TreeCtrl_Expand(PyObject *, PyObject *args, PyObject *kwargs) {
30538     PyObject *resultobj;
30539     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30540     wxTreeItemId *arg2 = 0 ;
30541     PyObject * obj0 = 0 ;
30542     PyObject * obj1 = 0 ;
30543     char *kwnames[] = {
30544         (char *) "self",(char *) "item", NULL
30545     };
30546
30547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Expand",kwnames,&obj0,&obj1)) goto fail;
30548     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30549     if (SWIG_arg_fail(1)) SWIG_fail;
30550     {
30551         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30552         if (SWIG_arg_fail(2)) SWIG_fail;
30553         if (arg2 == NULL) {
30554             SWIG_null_ref("wxTreeItemId");
30555         }
30556         if (SWIG_arg_fail(2)) SWIG_fail;
30557     }
30558     {
30559         PyThreadState* __tstate = wxPyBeginAllowThreads();
30560         (arg1)->Expand((wxTreeItemId const &)*arg2);
30561
30562         wxPyEndAllowThreads(__tstate);
30563         if (PyErr_Occurred()) SWIG_fail;
30564     }
30565     Py_INCREF(Py_None); resultobj = Py_None;
30566     return resultobj;
30567     fail:
30568     return NULL;
30569 }
30570
30571
30572 static PyObject *_wrap_TreeCtrl_Collapse(PyObject *, PyObject *args, PyObject *kwargs) {
30573     PyObject *resultobj;
30574     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30575     wxTreeItemId *arg2 = 0 ;
30576     PyObject * obj0 = 0 ;
30577     PyObject * obj1 = 0 ;
30578     char *kwnames[] = {
30579         (char *) "self",(char *) "item", NULL
30580     };
30581
30582     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Collapse",kwnames,&obj0,&obj1)) goto fail;
30583     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30584     if (SWIG_arg_fail(1)) SWIG_fail;
30585     {
30586         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30587         if (SWIG_arg_fail(2)) SWIG_fail;
30588         if (arg2 == NULL) {
30589             SWIG_null_ref("wxTreeItemId");
30590         }
30591         if (SWIG_arg_fail(2)) SWIG_fail;
30592     }
30593     {
30594         PyThreadState* __tstate = wxPyBeginAllowThreads();
30595         (arg1)->Collapse((wxTreeItemId const &)*arg2);
30596
30597         wxPyEndAllowThreads(__tstate);
30598         if (PyErr_Occurred()) SWIG_fail;
30599     }
30600     Py_INCREF(Py_None); resultobj = Py_None;
30601     return resultobj;
30602     fail:
30603     return NULL;
30604 }
30605
30606
30607 static PyObject *_wrap_TreeCtrl_CollapseAndReset(PyObject *, PyObject *args, PyObject *kwargs) {
30608     PyObject *resultobj;
30609     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30610     wxTreeItemId *arg2 = 0 ;
30611     PyObject * obj0 = 0 ;
30612     PyObject * obj1 = 0 ;
30613     char *kwnames[] = {
30614         (char *) "self",(char *) "item", NULL
30615     };
30616
30617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_CollapseAndReset",kwnames,&obj0,&obj1)) goto fail;
30618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30619     if (SWIG_arg_fail(1)) SWIG_fail;
30620     {
30621         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30622         if (SWIG_arg_fail(2)) SWIG_fail;
30623         if (arg2 == NULL) {
30624             SWIG_null_ref("wxTreeItemId");
30625         }
30626         if (SWIG_arg_fail(2)) SWIG_fail;
30627     }
30628     {
30629         PyThreadState* __tstate = wxPyBeginAllowThreads();
30630         (arg1)->CollapseAndReset((wxTreeItemId const &)*arg2);
30631
30632         wxPyEndAllowThreads(__tstate);
30633         if (PyErr_Occurred()) SWIG_fail;
30634     }
30635     Py_INCREF(Py_None); resultobj = Py_None;
30636     return resultobj;
30637     fail:
30638     return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_TreeCtrl_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
30643     PyObject *resultobj;
30644     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30645     wxTreeItemId *arg2 = 0 ;
30646     PyObject * obj0 = 0 ;
30647     PyObject * obj1 = 0 ;
30648     char *kwnames[] = {
30649         (char *) "self",(char *) "item", NULL
30650     };
30651
30652     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Toggle",kwnames,&obj0,&obj1)) goto fail;
30653     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30654     if (SWIG_arg_fail(1)) SWIG_fail;
30655     {
30656         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30657         if (SWIG_arg_fail(2)) SWIG_fail;
30658         if (arg2 == NULL) {
30659             SWIG_null_ref("wxTreeItemId");
30660         }
30661         if (SWIG_arg_fail(2)) SWIG_fail;
30662     }
30663     {
30664         PyThreadState* __tstate = wxPyBeginAllowThreads();
30665         (arg1)->Toggle((wxTreeItemId const &)*arg2);
30666
30667         wxPyEndAllowThreads(__tstate);
30668         if (PyErr_Occurred()) SWIG_fail;
30669     }
30670     Py_INCREF(Py_None); resultobj = Py_None;
30671     return resultobj;
30672     fail:
30673     return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_TreeCtrl_Unselect(PyObject *, PyObject *args, PyObject *kwargs) {
30678     PyObject *resultobj;
30679     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30680     PyObject * obj0 = 0 ;
30681     char *kwnames[] = {
30682         (char *) "self", NULL
30683     };
30684
30685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_Unselect",kwnames,&obj0)) goto fail;
30686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30687     if (SWIG_arg_fail(1)) SWIG_fail;
30688     {
30689         PyThreadState* __tstate = wxPyBeginAllowThreads();
30690         (arg1)->Unselect();
30691
30692         wxPyEndAllowThreads(__tstate);
30693         if (PyErr_Occurred()) SWIG_fail;
30694     }
30695     Py_INCREF(Py_None); resultobj = Py_None;
30696     return resultobj;
30697     fail:
30698     return NULL;
30699 }
30700
30701
30702 static PyObject *_wrap_TreeCtrl_UnselectItem(PyObject *, PyObject *args, PyObject *kwargs) {
30703     PyObject *resultobj;
30704     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30705     wxTreeItemId *arg2 = 0 ;
30706     PyObject * obj0 = 0 ;
30707     PyObject * obj1 = 0 ;
30708     char *kwnames[] = {
30709         (char *) "self",(char *) "item", NULL
30710     };
30711
30712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_UnselectItem",kwnames,&obj0,&obj1)) goto fail;
30713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30714     if (SWIG_arg_fail(1)) SWIG_fail;
30715     {
30716         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30717         if (SWIG_arg_fail(2)) SWIG_fail;
30718         if (arg2 == NULL) {
30719             SWIG_null_ref("wxTreeItemId");
30720         }
30721         if (SWIG_arg_fail(2)) SWIG_fail;
30722     }
30723     {
30724         PyThreadState* __tstate = wxPyBeginAllowThreads();
30725         (arg1)->UnselectItem((wxTreeItemId const &)*arg2);
30726
30727         wxPyEndAllowThreads(__tstate);
30728         if (PyErr_Occurred()) SWIG_fail;
30729     }
30730     Py_INCREF(Py_None); resultobj = Py_None;
30731     return resultobj;
30732     fail:
30733     return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_TreeCtrl_UnselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
30738     PyObject *resultobj;
30739     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30740     PyObject * obj0 = 0 ;
30741     char *kwnames[] = {
30742         (char *) "self", NULL
30743     };
30744
30745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_UnselectAll",kwnames,&obj0)) goto fail;
30746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30747     if (SWIG_arg_fail(1)) SWIG_fail;
30748     {
30749         PyThreadState* __tstate = wxPyBeginAllowThreads();
30750         (arg1)->UnselectAll();
30751
30752         wxPyEndAllowThreads(__tstate);
30753         if (PyErr_Occurred()) SWIG_fail;
30754     }
30755     Py_INCREF(Py_None); resultobj = Py_None;
30756     return resultobj;
30757     fail:
30758     return NULL;
30759 }
30760
30761
30762 static PyObject *_wrap_TreeCtrl_SelectItem(PyObject *, PyObject *args, PyObject *kwargs) {
30763     PyObject *resultobj;
30764     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30765     wxTreeItemId *arg2 = 0 ;
30766     bool arg3 = (bool) true ;
30767     PyObject * obj0 = 0 ;
30768     PyObject * obj1 = 0 ;
30769     PyObject * obj2 = 0 ;
30770     char *kwnames[] = {
30771         (char *) "self",(char *) "item",(char *) "select", NULL
30772     };
30773
30774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SelectItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
30775     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30776     if (SWIG_arg_fail(1)) SWIG_fail;
30777     {
30778         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30779         if (SWIG_arg_fail(2)) SWIG_fail;
30780         if (arg2 == NULL) {
30781             SWIG_null_ref("wxTreeItemId");
30782         }
30783         if (SWIG_arg_fail(2)) SWIG_fail;
30784     }
30785     if (obj2) {
30786         {
30787             arg3 = (bool)(SWIG_As_bool(obj2));
30788             if (SWIG_arg_fail(3)) SWIG_fail;
30789         }
30790     }
30791     {
30792         PyThreadState* __tstate = wxPyBeginAllowThreads();
30793         (arg1)->SelectItem((wxTreeItemId const &)*arg2,arg3);
30794
30795         wxPyEndAllowThreads(__tstate);
30796         if (PyErr_Occurred()) SWIG_fail;
30797     }
30798     Py_INCREF(Py_None); resultobj = Py_None;
30799     return resultobj;
30800     fail:
30801     return NULL;
30802 }
30803
30804
30805 static PyObject *_wrap_TreeCtrl_ToggleItemSelection(PyObject *, PyObject *args, PyObject *kwargs) {
30806     PyObject *resultobj;
30807     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30808     wxTreeItemId *arg2 = 0 ;
30809     PyObject * obj0 = 0 ;
30810     PyObject * obj1 = 0 ;
30811     char *kwnames[] = {
30812         (char *) "self",(char *) "item", NULL
30813     };
30814
30815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ToggleItemSelection",kwnames,&obj0,&obj1)) goto fail;
30816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30817     if (SWIG_arg_fail(1)) SWIG_fail;
30818     {
30819         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30820         if (SWIG_arg_fail(2)) SWIG_fail;
30821         if (arg2 == NULL) {
30822             SWIG_null_ref("wxTreeItemId");
30823         }
30824         if (SWIG_arg_fail(2)) SWIG_fail;
30825     }
30826     {
30827         PyThreadState* __tstate = wxPyBeginAllowThreads();
30828         (arg1)->ToggleItemSelection((wxTreeItemId const &)*arg2);
30829
30830         wxPyEndAllowThreads(__tstate);
30831         if (PyErr_Occurred()) SWIG_fail;
30832     }
30833     Py_INCREF(Py_None); resultobj = Py_None;
30834     return resultobj;
30835     fail:
30836     return NULL;
30837 }
30838
30839
30840 static PyObject *_wrap_TreeCtrl_EnsureVisible(PyObject *, PyObject *args, PyObject *kwargs) {
30841     PyObject *resultobj;
30842     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30843     wxTreeItemId *arg2 = 0 ;
30844     PyObject * obj0 = 0 ;
30845     PyObject * obj1 = 0 ;
30846     char *kwnames[] = {
30847         (char *) "self",(char *) "item", NULL
30848     };
30849
30850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EnsureVisible",kwnames,&obj0,&obj1)) goto fail;
30851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30852     if (SWIG_arg_fail(1)) SWIG_fail;
30853     {
30854         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30855         if (SWIG_arg_fail(2)) SWIG_fail;
30856         if (arg2 == NULL) {
30857             SWIG_null_ref("wxTreeItemId");
30858         }
30859         if (SWIG_arg_fail(2)) SWIG_fail;
30860     }
30861     {
30862         PyThreadState* __tstate = wxPyBeginAllowThreads();
30863         (arg1)->EnsureVisible((wxTreeItemId const &)*arg2);
30864
30865         wxPyEndAllowThreads(__tstate);
30866         if (PyErr_Occurred()) SWIG_fail;
30867     }
30868     Py_INCREF(Py_None); resultobj = Py_None;
30869     return resultobj;
30870     fail:
30871     return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_TreeCtrl_ScrollTo(PyObject *, PyObject *args, PyObject *kwargs) {
30876     PyObject *resultobj;
30877     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30878     wxTreeItemId *arg2 = 0 ;
30879     PyObject * obj0 = 0 ;
30880     PyObject * obj1 = 0 ;
30881     char *kwnames[] = {
30882         (char *) "self",(char *) "item", NULL
30883     };
30884
30885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ScrollTo",kwnames,&obj0,&obj1)) goto fail;
30886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30887     if (SWIG_arg_fail(1)) SWIG_fail;
30888     {
30889         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30890         if (SWIG_arg_fail(2)) SWIG_fail;
30891         if (arg2 == NULL) {
30892             SWIG_null_ref("wxTreeItemId");
30893         }
30894         if (SWIG_arg_fail(2)) SWIG_fail;
30895     }
30896     {
30897         PyThreadState* __tstate = wxPyBeginAllowThreads();
30898         (arg1)->ScrollTo((wxTreeItemId const &)*arg2);
30899
30900         wxPyEndAllowThreads(__tstate);
30901         if (PyErr_Occurred()) SWIG_fail;
30902     }
30903     Py_INCREF(Py_None); resultobj = Py_None;
30904     return resultobj;
30905     fail:
30906     return NULL;
30907 }
30908
30909
30910 static PyObject *_wrap_TreeCtrl_EditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
30911     PyObject *resultobj;
30912     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30913     wxTreeItemId *arg2 = 0 ;
30914     PyObject * obj0 = 0 ;
30915     PyObject * obj1 = 0 ;
30916     char *kwnames[] = {
30917         (char *) "self",(char *) "item", NULL
30918     };
30919
30920     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EditLabel",kwnames,&obj0,&obj1)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30925         if (SWIG_arg_fail(2)) SWIG_fail;
30926         if (arg2 == NULL) {
30927             SWIG_null_ref("wxTreeItemId");
30928         }
30929         if (SWIG_arg_fail(2)) SWIG_fail;
30930     }
30931     {
30932         PyThreadState* __tstate = wxPyBeginAllowThreads();
30933         (arg1)->EditLabel((wxTreeItemId const &)*arg2);
30934
30935         wxPyEndAllowThreads(__tstate);
30936         if (PyErr_Occurred()) SWIG_fail;
30937     }
30938     Py_INCREF(Py_None); resultobj = Py_None;
30939     return resultobj;
30940     fail:
30941     return NULL;
30942 }
30943
30944
30945 static PyObject *_wrap_TreeCtrl_GetEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
30946     PyObject *resultobj;
30947     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30948     wxTextCtrl *result;
30949     PyObject * obj0 = 0 ;
30950     char *kwnames[] = {
30951         (char *) "self", NULL
30952     };
30953
30954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TreeCtrl_GetEditControl",kwnames,&obj0)) goto fail;
30955     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30956     if (SWIG_arg_fail(1)) SWIG_fail;
30957     {
30958         PyThreadState* __tstate = wxPyBeginAllowThreads();
30959         result = (wxTextCtrl *)((wxPyTreeCtrl const *)arg1)->GetEditControl();
30960
30961         wxPyEndAllowThreads(__tstate);
30962         if (PyErr_Occurred()) SWIG_fail;
30963     }
30964     {
30965         resultobj = wxPyMake_wxObject(result, 0);
30966     }
30967     return resultobj;
30968     fail:
30969     return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_TreeCtrl_EndEditLabel(PyObject *, PyObject *args, PyObject *kwargs) {
30974     PyObject *resultobj;
30975     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
30976     wxTreeItemId *arg2 = 0 ;
30977     bool arg3 = (bool) false ;
30978     PyObject * obj0 = 0 ;
30979     PyObject * obj1 = 0 ;
30980     PyObject * obj2 = 0 ;
30981     char *kwnames[] = {
30982         (char *) "self",(char *) "item",(char *) "discardChanges", NULL
30983     };
30984
30985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_EndEditLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
30986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
30987     if (SWIG_arg_fail(1)) SWIG_fail;
30988     {
30989         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
30990         if (SWIG_arg_fail(2)) SWIG_fail;
30991         if (arg2 == NULL) {
30992             SWIG_null_ref("wxTreeItemId");
30993         }
30994         if (SWIG_arg_fail(2)) SWIG_fail;
30995     }
30996     if (obj2) {
30997         {
30998             arg3 = (bool)(SWIG_As_bool(obj2));
30999             if (SWIG_arg_fail(3)) SWIG_fail;
31000         }
31001     }
31002     {
31003         PyThreadState* __tstate = wxPyBeginAllowThreads();
31004         (arg1)->EndEditLabel((wxTreeItemId const &)*arg2,arg3);
31005
31006         wxPyEndAllowThreads(__tstate);
31007         if (PyErr_Occurred()) SWIG_fail;
31008     }
31009     Py_INCREF(Py_None); resultobj = Py_None;
31010     return resultobj;
31011     fail:
31012     return NULL;
31013 }
31014
31015
31016 static PyObject *_wrap_TreeCtrl_SortChildren(PyObject *, PyObject *args, PyObject *kwargs) {
31017     PyObject *resultobj;
31018     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31019     wxTreeItemId *arg2 = 0 ;
31020     PyObject * obj0 = 0 ;
31021     PyObject * obj1 = 0 ;
31022     char *kwnames[] = {
31023         (char *) "self",(char *) "item", NULL
31024     };
31025
31026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SortChildren",kwnames,&obj0,&obj1)) goto fail;
31027     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31028     if (SWIG_arg_fail(1)) SWIG_fail;
31029     {
31030         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31031         if (SWIG_arg_fail(2)) SWIG_fail;
31032         if (arg2 == NULL) {
31033             SWIG_null_ref("wxTreeItemId");
31034         }
31035         if (SWIG_arg_fail(2)) SWIG_fail;
31036     }
31037     {
31038         PyThreadState* __tstate = wxPyBeginAllowThreads();
31039         (arg1)->SortChildren((wxTreeItemId const &)*arg2);
31040
31041         wxPyEndAllowThreads(__tstate);
31042         if (PyErr_Occurred()) SWIG_fail;
31043     }
31044     Py_INCREF(Py_None); resultobj = Py_None;
31045     return resultobj;
31046     fail:
31047     return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_TreeCtrl_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31052     PyObject *resultobj;
31053     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31054     wxPoint *arg2 = 0 ;
31055     int *arg3 = 0 ;
31056     wxTreeItemId result;
31057     wxPoint temp2 ;
31058     int temp3 ;
31059     int res3 = 0 ;
31060     PyObject * obj0 = 0 ;
31061     PyObject * obj1 = 0 ;
31062     char *kwnames[] = {
31063         (char *) "self",(char *) "point", NULL
31064     };
31065
31066     arg3 = &temp3; res3 = SWIG_NEWOBJ;
31067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_HitTest",kwnames,&obj0,&obj1)) goto fail;
31068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31069     if (SWIG_arg_fail(1)) SWIG_fail;
31070     {
31071         arg2 = &temp2;
31072         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31073     }
31074     {
31075         PyThreadState* __tstate = wxPyBeginAllowThreads();
31076         result = (arg1)->HitTest((wxPoint const &)*arg2,*arg3);
31077
31078         wxPyEndAllowThreads(__tstate);
31079         if (PyErr_Occurred()) SWIG_fail;
31080     }
31081     {
31082         wxTreeItemId * resultptr;
31083         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
31084         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
31085     }
31086     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31087     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31088     return resultobj;
31089     fail:
31090     return NULL;
31091 }
31092
31093
31094 static PyObject *_wrap_TreeCtrl_GetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
31095     PyObject *resultobj;
31096     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31097     wxTreeItemId *arg2 = 0 ;
31098     bool arg3 = (bool) false ;
31099     PyObject *result;
31100     PyObject * obj0 = 0 ;
31101     PyObject * obj1 = 0 ;
31102     PyObject * obj2 = 0 ;
31103     char *kwnames[] = {
31104         (char *) "self",(char *) "item",(char *) "textOnly", NULL
31105     };
31106
31107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetBoundingRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
31108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31109     if (SWIG_arg_fail(1)) SWIG_fail;
31110     {
31111         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31112         if (SWIG_arg_fail(2)) SWIG_fail;
31113         if (arg2 == NULL) {
31114             SWIG_null_ref("wxTreeItemId");
31115         }
31116         if (SWIG_arg_fail(2)) SWIG_fail;
31117     }
31118     if (obj2) {
31119         {
31120             arg3 = (bool)(SWIG_As_bool(obj2));
31121             if (SWIG_arg_fail(3)) SWIG_fail;
31122         }
31123     }
31124     {
31125         PyThreadState* __tstate = wxPyBeginAllowThreads();
31126         result = (PyObject *)wxPyTreeCtrl_GetBoundingRect(arg1,(wxTreeItemId const &)*arg2,arg3);
31127
31128         wxPyEndAllowThreads(__tstate);
31129         if (PyErr_Occurred()) SWIG_fail;
31130     }
31131     resultobj = result;
31132     return resultobj;
31133     fail:
31134     return NULL;
31135 }
31136
31137
31138 static PyObject *_wrap_TreeCtrl_SetState(PyObject *, PyObject *args, PyObject *kwargs) {
31139     PyObject *resultobj;
31140     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31141     wxTreeItemId *arg2 = 0 ;
31142     int arg3 ;
31143     PyObject * obj0 = 0 ;
31144     PyObject * obj1 = 0 ;
31145     PyObject * obj2 = 0 ;
31146     char *kwnames[] = {
31147         (char *) "self",(char *) "node",(char *) "state", NULL
31148     };
31149
31150     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetState",kwnames,&obj0,&obj1,&obj2)) goto fail;
31151     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31152     if (SWIG_arg_fail(1)) SWIG_fail;
31153     {
31154         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31155         if (SWIG_arg_fail(2)) SWIG_fail;
31156         if (arg2 == NULL) {
31157             SWIG_null_ref("wxTreeItemId");
31158         }
31159         if (SWIG_arg_fail(2)) SWIG_fail;
31160     }
31161     {
31162         arg3 = (int)(SWIG_As_int(obj2));
31163         if (SWIG_arg_fail(3)) SWIG_fail;
31164     }
31165     {
31166         PyThreadState* __tstate = wxPyBeginAllowThreads();
31167         (arg1)->SetState((wxTreeItemId const &)*arg2,arg3);
31168
31169         wxPyEndAllowThreads(__tstate);
31170         if (PyErr_Occurred()) SWIG_fail;
31171     }
31172     Py_INCREF(Py_None); resultobj = Py_None;
31173     return resultobj;
31174     fail:
31175     return NULL;
31176 }
31177
31178
31179 static PyObject *_wrap_TreeCtrl_GetState(PyObject *, PyObject *args, PyObject *kwargs) {
31180     PyObject *resultobj;
31181     wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
31182     wxTreeItemId *arg2 = 0 ;
31183     int result;
31184     PyObject * obj0 = 0 ;
31185     PyObject * obj1 = 0 ;
31186     char *kwnames[] = {
31187         (char *) "self",(char *) "node", NULL
31188     };
31189
31190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetState",kwnames,&obj0,&obj1)) goto fail;
31191     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
31192     if (SWIG_arg_fail(1)) SWIG_fail;
31193     {
31194         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
31195         if (SWIG_arg_fail(2)) SWIG_fail;
31196         if (arg2 == NULL) {
31197             SWIG_null_ref("wxTreeItemId");
31198         }
31199         if (SWIG_arg_fail(2)) SWIG_fail;
31200     }
31201     {
31202         PyThreadState* __tstate = wxPyBeginAllowThreads();
31203         result = (int)(arg1)->GetState((wxTreeItemId const &)*arg2);
31204
31205         wxPyEndAllowThreads(__tstate);
31206         if (PyErr_Occurred()) SWIG_fail;
31207     }
31208     {
31209         resultobj = SWIG_From_int((int)(result));
31210     }
31211     return resultobj;
31212     fail:
31213     return NULL;
31214 }
31215
31216
31217 static PyObject *_wrap_TreeCtrl_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31218     PyObject *resultobj;
31219     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
31220     wxVisualAttributes result;
31221     PyObject * obj0 = 0 ;
31222     char *kwnames[] = {
31223         (char *) "variant", NULL
31224     };
31225
31226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TreeCtrl_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
31227     if (obj0) {
31228         {
31229             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
31230             if (SWIG_arg_fail(1)) SWIG_fail;
31231         }
31232     }
31233     {
31234         if (!wxPyCheckForApp()) SWIG_fail;
31235         PyThreadState* __tstate = wxPyBeginAllowThreads();
31236         result = wxPyTreeCtrl::GetClassDefaultAttributes((wxWindowVariant )arg1);
31237
31238         wxPyEndAllowThreads(__tstate);
31239         if (PyErr_Occurred()) SWIG_fail;
31240     }
31241     {
31242         wxVisualAttributes * resultptr;
31243         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
31244         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
31245     }
31246     return resultobj;
31247     fail:
31248     return NULL;
31249 }
31250
31251
31252 static PyObject * TreeCtrl_swigregister(PyObject *, PyObject *args) {
31253     PyObject *obj;
31254     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31255     SWIG_TypeClientData(SWIGTYPE_p_wxPyTreeCtrl, obj);
31256     Py_INCREF(obj);
31257     return Py_BuildValue((char *)"");
31258 }
31259 static int _wrap_DirDialogDefaultFolderStr_set(PyObject *) {
31260     PyErr_SetString(PyExc_TypeError,"Variable DirDialogDefaultFolderStr is read-only.");
31261     return 1;
31262 }
31263
31264
31265 static PyObject *_wrap_DirDialogDefaultFolderStr_get(void) {
31266     PyObject *pyobj;
31267
31268     {
31269 #if wxUSE_UNICODE
31270         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
31271 #else
31272         pyobj = PyString_FromStringAndSize((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
31273 #endif
31274     }
31275     return pyobj;
31276 }
31277
31278
31279 static PyObject *_wrap_new_GenericDirCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
31280     PyObject *resultobj;
31281     wxWindow *arg1 = (wxWindow *) 0 ;
31282     int arg2 = (int) (int)-1 ;
31283     wxString const &arg3_defvalue = wxPyDirDialogDefaultFolderStr ;
31284     wxString *arg3 = (wxString *) &arg3_defvalue ;
31285     wxPoint const &arg4_defvalue = wxDefaultPosition ;
31286     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
31287     wxSize const &arg5_defvalue = wxDefaultSize ;
31288     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
31289     long arg6 = (long) wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER ;
31290     wxString const &arg7_defvalue = wxPyEmptyString ;
31291     wxString *arg7 = (wxString *) &arg7_defvalue ;
31292     int arg8 = (int) 0 ;
31293     wxString const &arg9_defvalue = wxPyTreeCtrlNameStr ;
31294     wxString *arg9 = (wxString *) &arg9_defvalue ;
31295     wxGenericDirCtrl *result;
31296     bool temp3 = false ;
31297     wxPoint temp4 ;
31298     wxSize temp5 ;
31299     bool temp7 = false ;
31300     bool temp9 = false ;
31301     PyObject * obj0 = 0 ;
31302     PyObject * obj1 = 0 ;
31303     PyObject * obj2 = 0 ;
31304     PyObject * obj3 = 0 ;
31305     PyObject * obj4 = 0 ;
31306     PyObject * obj5 = 0 ;
31307     PyObject * obj6 = 0 ;
31308     PyObject * obj7 = 0 ;
31309     PyObject * obj8 = 0 ;
31310     char *kwnames[] = {
31311         (char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL
31312     };
31313
31314     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_GenericDirCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
31315     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31316     if (SWIG_arg_fail(1)) SWIG_fail;
31317     if (obj1) {
31318         {
31319             arg2 = (int const)(SWIG_As_int(obj1));
31320             if (SWIG_arg_fail(2)) SWIG_fail;
31321         }
31322     }
31323     if (obj2) {
31324         {
31325             arg3 = wxString_in_helper(obj2);
31326             if (arg3 == NULL) SWIG_fail;
31327             temp3 = true;
31328         }
31329     }
31330     if (obj3) {
31331         {
31332             arg4 = &temp4;
31333             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
31334         }
31335     }
31336     if (obj4) {
31337         {
31338             arg5 = &temp5;
31339             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
31340         }
31341     }
31342     if (obj5) {
31343         {
31344             arg6 = (long)(SWIG_As_long(obj5));
31345             if (SWIG_arg_fail(6)) SWIG_fail;
31346         }
31347     }
31348     if (obj6) {
31349         {
31350             arg7 = wxString_in_helper(obj6);
31351             if (arg7 == NULL) SWIG_fail;
31352             temp7 = true;
31353         }
31354     }
31355     if (obj7) {
31356         {
31357             arg8 = (int)(SWIG_As_int(obj7));
31358             if (SWIG_arg_fail(8)) SWIG_fail;
31359         }
31360     }
31361     if (obj8) {
31362         {
31363             arg9 = wxString_in_helper(obj8);
31364             if (arg9 == NULL) SWIG_fail;
31365             temp9 = true;
31366         }
31367     }
31368     {
31369         if (!wxPyCheckForApp()) SWIG_fail;
31370         PyThreadState* __tstate = wxPyBeginAllowThreads();
31371         result = (wxGenericDirCtrl *)new wxGenericDirCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7,arg8,(wxString const &)*arg9);
31372
31373         wxPyEndAllowThreads(__tstate);
31374         if (PyErr_Occurred()) SWIG_fail;
31375     }
31376     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDirCtrl, 1);
31377     {
31378         if (temp3)
31379         delete arg3;
31380     }
31381     {
31382         if (temp7)
31383         delete arg7;
31384     }
31385     {
31386         if (temp9)
31387         delete arg9;
31388     }
31389     return resultobj;
31390     fail:
31391     {
31392         if (temp3)
31393         delete arg3;
31394     }
31395     {
31396         if (temp7)
31397         delete arg7;
31398     }
31399     {
31400         if (temp9)
31401         delete arg9;
31402     }
31403     return NULL;
31404 }
31405
31406
31407 static PyObject *_wrap_new_PreGenericDirCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
31408     PyObject *resultobj;
31409     wxGenericDirCtrl *result;
31410     char *kwnames[] = {
31411         NULL
31412     };
31413
31414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGenericDirCtrl",kwnames)) goto fail;
31415     {
31416         if (!wxPyCheckForApp()) SWIG_fail;
31417         PyThreadState* __tstate = wxPyBeginAllowThreads();
31418         result = (wxGenericDirCtrl *)new wxGenericDirCtrl();
31419
31420         wxPyEndAllowThreads(__tstate);
31421         if (PyErr_Occurred()) SWIG_fail;
31422     }
31423     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDirCtrl, 1);
31424     return resultobj;
31425     fail:
31426     return NULL;
31427 }
31428
31429
31430 static PyObject *_wrap_GenericDirCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
31431     PyObject *resultobj;
31432     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31433     wxWindow *arg2 = (wxWindow *) 0 ;
31434     int arg3 = (int) (int)-1 ;
31435     wxString const &arg4_defvalue = wxPyDirDialogDefaultFolderStr ;
31436     wxString *arg4 = (wxString *) &arg4_defvalue ;
31437     wxPoint const &arg5_defvalue = wxDefaultPosition ;
31438     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
31439     wxSize const &arg6_defvalue = wxDefaultSize ;
31440     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
31441     long arg7 = (long) wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER ;
31442     wxString const &arg8_defvalue = wxPyEmptyString ;
31443     wxString *arg8 = (wxString *) &arg8_defvalue ;
31444     int arg9 = (int) 0 ;
31445     wxString const &arg10_defvalue = wxPyTreeCtrlNameStr ;
31446     wxString *arg10 = (wxString *) &arg10_defvalue ;
31447     bool result;
31448     bool temp4 = false ;
31449     wxPoint temp5 ;
31450     wxSize temp6 ;
31451     bool temp8 = false ;
31452     bool temp10 = false ;
31453     PyObject * obj0 = 0 ;
31454     PyObject * obj1 = 0 ;
31455     PyObject * obj2 = 0 ;
31456     PyObject * obj3 = 0 ;
31457     PyObject * obj4 = 0 ;
31458     PyObject * obj5 = 0 ;
31459     PyObject * obj6 = 0 ;
31460     PyObject * obj7 = 0 ;
31461     PyObject * obj8 = 0 ;
31462     PyObject * obj9 = 0 ;
31463     char *kwnames[] = {
31464         (char *) "self",(char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL
31465     };
31466
31467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:GenericDirCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
31468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31469     if (SWIG_arg_fail(1)) SWIG_fail;
31470     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31471     if (SWIG_arg_fail(2)) SWIG_fail;
31472     if (obj2) {
31473         {
31474             arg3 = (int const)(SWIG_As_int(obj2));
31475             if (SWIG_arg_fail(3)) SWIG_fail;
31476         }
31477     }
31478     if (obj3) {
31479         {
31480             arg4 = wxString_in_helper(obj3);
31481             if (arg4 == NULL) SWIG_fail;
31482             temp4 = true;
31483         }
31484     }
31485     if (obj4) {
31486         {
31487             arg5 = &temp5;
31488             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
31489         }
31490     }
31491     if (obj5) {
31492         {
31493             arg6 = &temp6;
31494             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
31495         }
31496     }
31497     if (obj6) {
31498         {
31499             arg7 = (long)(SWIG_As_long(obj6));
31500             if (SWIG_arg_fail(7)) SWIG_fail;
31501         }
31502     }
31503     if (obj7) {
31504         {
31505             arg8 = wxString_in_helper(obj7);
31506             if (arg8 == NULL) SWIG_fail;
31507             temp8 = true;
31508         }
31509     }
31510     if (obj8) {
31511         {
31512             arg9 = (int)(SWIG_As_int(obj8));
31513             if (SWIG_arg_fail(9)) SWIG_fail;
31514         }
31515     }
31516     if (obj9) {
31517         {
31518             arg10 = wxString_in_helper(obj9);
31519             if (arg10 == NULL) SWIG_fail;
31520             temp10 = true;
31521         }
31522     }
31523     {
31524         PyThreadState* __tstate = wxPyBeginAllowThreads();
31525         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8,arg9,(wxString const &)*arg10);
31526
31527         wxPyEndAllowThreads(__tstate);
31528         if (PyErr_Occurred()) SWIG_fail;
31529     }
31530     {
31531         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31532     }
31533     {
31534         if (temp4)
31535         delete arg4;
31536     }
31537     {
31538         if (temp8)
31539         delete arg8;
31540     }
31541     {
31542         if (temp10)
31543         delete arg10;
31544     }
31545     return resultobj;
31546     fail:
31547     {
31548         if (temp4)
31549         delete arg4;
31550     }
31551     {
31552         if (temp8)
31553         delete arg8;
31554     }
31555     {
31556         if (temp10)
31557         delete arg10;
31558     }
31559     return NULL;
31560 }
31561
31562
31563 static PyObject *_wrap_GenericDirCtrl_ExpandPath(PyObject *, PyObject *args, PyObject *kwargs) {
31564     PyObject *resultobj;
31565     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31566     wxString *arg2 = 0 ;
31567     bool result;
31568     bool temp2 = false ;
31569     PyObject * obj0 = 0 ;
31570     PyObject * obj1 = 0 ;
31571     char *kwnames[] = {
31572         (char *) "self",(char *) "path", NULL
31573     };
31574
31575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ExpandPath",kwnames,&obj0,&obj1)) goto fail;
31576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31577     if (SWIG_arg_fail(1)) SWIG_fail;
31578     {
31579         arg2 = wxString_in_helper(obj1);
31580         if (arg2 == NULL) SWIG_fail;
31581         temp2 = true;
31582     }
31583     {
31584         PyThreadState* __tstate = wxPyBeginAllowThreads();
31585         result = (bool)(arg1)->ExpandPath((wxString const &)*arg2);
31586
31587         wxPyEndAllowThreads(__tstate);
31588         if (PyErr_Occurred()) SWIG_fail;
31589     }
31590     {
31591         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31592     }
31593     {
31594         if (temp2)
31595         delete arg2;
31596     }
31597     return resultobj;
31598     fail:
31599     {
31600         if (temp2)
31601         delete arg2;
31602     }
31603     return NULL;
31604 }
31605
31606
31607 static PyObject *_wrap_GenericDirCtrl_GetDefaultPath(PyObject *, PyObject *args, PyObject *kwargs) {
31608     PyObject *resultobj;
31609     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31610     wxString result;
31611     PyObject * obj0 = 0 ;
31612     char *kwnames[] = {
31613         (char *) "self", NULL
31614     };
31615
31616     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetDefaultPath",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
31621         result = ((wxGenericDirCtrl const *)arg1)->GetDefaultPath();
31622
31623         wxPyEndAllowThreads(__tstate);
31624         if (PyErr_Occurred()) SWIG_fail;
31625     }
31626     {
31627 #if wxUSE_UNICODE
31628         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31629 #else
31630         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31631 #endif
31632     }
31633     return resultobj;
31634     fail:
31635     return NULL;
31636 }
31637
31638
31639 static PyObject *_wrap_GenericDirCtrl_SetDefaultPath(PyObject *, PyObject *args, PyObject *kwargs) {
31640     PyObject *resultobj;
31641     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31642     wxString *arg2 = 0 ;
31643     bool temp2 = false ;
31644     PyObject * obj0 = 0 ;
31645     PyObject * obj1 = 0 ;
31646     char *kwnames[] = {
31647         (char *) "self",(char *) "path", NULL
31648     };
31649
31650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetDefaultPath",kwnames,&obj0,&obj1)) goto fail;
31651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31652     if (SWIG_arg_fail(1)) SWIG_fail;
31653     {
31654         arg2 = wxString_in_helper(obj1);
31655         if (arg2 == NULL) SWIG_fail;
31656         temp2 = true;
31657     }
31658     {
31659         PyThreadState* __tstate = wxPyBeginAllowThreads();
31660         (arg1)->SetDefaultPath((wxString const &)*arg2);
31661
31662         wxPyEndAllowThreads(__tstate);
31663         if (PyErr_Occurred()) SWIG_fail;
31664     }
31665     Py_INCREF(Py_None); resultobj = Py_None;
31666     {
31667         if (temp2)
31668         delete arg2;
31669     }
31670     return resultobj;
31671     fail:
31672     {
31673         if (temp2)
31674         delete arg2;
31675     }
31676     return NULL;
31677 }
31678
31679
31680 static PyObject *_wrap_GenericDirCtrl_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
31681     PyObject *resultobj;
31682     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31683     wxString result;
31684     PyObject * obj0 = 0 ;
31685     char *kwnames[] = {
31686         (char *) "self", NULL
31687     };
31688
31689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetPath",kwnames,&obj0)) goto fail;
31690     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31691     if (SWIG_arg_fail(1)) SWIG_fail;
31692     {
31693         PyThreadState* __tstate = wxPyBeginAllowThreads();
31694         result = ((wxGenericDirCtrl const *)arg1)->GetPath();
31695
31696         wxPyEndAllowThreads(__tstate);
31697         if (PyErr_Occurred()) SWIG_fail;
31698     }
31699     {
31700 #if wxUSE_UNICODE
31701         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31702 #else
31703         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31704 #endif
31705     }
31706     return resultobj;
31707     fail:
31708     return NULL;
31709 }
31710
31711
31712 static PyObject *_wrap_GenericDirCtrl_GetFilePath(PyObject *, PyObject *args, PyObject *kwargs) {
31713     PyObject *resultobj;
31714     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31715     wxString result;
31716     PyObject * obj0 = 0 ;
31717     char *kwnames[] = {
31718         (char *) "self", NULL
31719     };
31720
31721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilePath",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
31726         result = ((wxGenericDirCtrl const *)arg1)->GetFilePath();
31727
31728         wxPyEndAllowThreads(__tstate);
31729         if (PyErr_Occurred()) SWIG_fail;
31730     }
31731     {
31732 #if wxUSE_UNICODE
31733         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31734 #else
31735         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31736 #endif
31737     }
31738     return resultobj;
31739     fail:
31740     return NULL;
31741 }
31742
31743
31744 static PyObject *_wrap_GenericDirCtrl_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
31745     PyObject *resultobj;
31746     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31747     wxString *arg2 = 0 ;
31748     bool temp2 = false ;
31749     PyObject * obj0 = 0 ;
31750     PyObject * obj1 = 0 ;
31751     char *kwnames[] = {
31752         (char *) "self",(char *) "path", NULL
31753     };
31754
31755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetPath",kwnames,&obj0,&obj1)) goto fail;
31756     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31757     if (SWIG_arg_fail(1)) SWIG_fail;
31758     {
31759         arg2 = wxString_in_helper(obj1);
31760         if (arg2 == NULL) SWIG_fail;
31761         temp2 = true;
31762     }
31763     {
31764         PyThreadState* __tstate = wxPyBeginAllowThreads();
31765         (arg1)->SetPath((wxString const &)*arg2);
31766
31767         wxPyEndAllowThreads(__tstate);
31768         if (PyErr_Occurred()) SWIG_fail;
31769     }
31770     Py_INCREF(Py_None); resultobj = Py_None;
31771     {
31772         if (temp2)
31773         delete arg2;
31774     }
31775     return resultobj;
31776     fail:
31777     {
31778         if (temp2)
31779         delete arg2;
31780     }
31781     return NULL;
31782 }
31783
31784
31785 static PyObject *_wrap_GenericDirCtrl_ShowHidden(PyObject *, PyObject *args, PyObject *kwargs) {
31786     PyObject *resultobj;
31787     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31788     bool arg2 ;
31789     PyObject * obj0 = 0 ;
31790     PyObject * obj1 = 0 ;
31791     char *kwnames[] = {
31792         (char *) "self",(char *) "show", NULL
31793     };
31794
31795     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ShowHidden",kwnames,&obj0,&obj1)) goto fail;
31796     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31797     if (SWIG_arg_fail(1)) SWIG_fail;
31798     {
31799         arg2 = (bool)(SWIG_As_bool(obj1));
31800         if (SWIG_arg_fail(2)) SWIG_fail;
31801     }
31802     {
31803         PyThreadState* __tstate = wxPyBeginAllowThreads();
31804         (arg1)->ShowHidden(arg2);
31805
31806         wxPyEndAllowThreads(__tstate);
31807         if (PyErr_Occurred()) SWIG_fail;
31808     }
31809     Py_INCREF(Py_None); resultobj = Py_None;
31810     return resultobj;
31811     fail:
31812     return NULL;
31813 }
31814
31815
31816 static PyObject *_wrap_GenericDirCtrl_GetShowHidden(PyObject *, PyObject *args, PyObject *kwargs) {
31817     PyObject *resultobj;
31818     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31819     bool result;
31820     PyObject * obj0 = 0 ;
31821     char *kwnames[] = {
31822         (char *) "self", NULL
31823     };
31824
31825     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetShowHidden",kwnames,&obj0)) goto fail;
31826     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31827     if (SWIG_arg_fail(1)) SWIG_fail;
31828     {
31829         PyThreadState* __tstate = wxPyBeginAllowThreads();
31830         result = (bool)(arg1)->GetShowHidden();
31831
31832         wxPyEndAllowThreads(__tstate);
31833         if (PyErr_Occurred()) SWIG_fail;
31834     }
31835     {
31836         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31837     }
31838     return resultobj;
31839     fail:
31840     return NULL;
31841 }
31842
31843
31844 static PyObject *_wrap_GenericDirCtrl_GetFilter(PyObject *, PyObject *args, PyObject *kwargs) {
31845     PyObject *resultobj;
31846     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31847     wxString result;
31848     PyObject * obj0 = 0 ;
31849     char *kwnames[] = {
31850         (char *) "self", NULL
31851     };
31852
31853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilter",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
31858         result = ((wxGenericDirCtrl const *)arg1)->GetFilter();
31859
31860         wxPyEndAllowThreads(__tstate);
31861         if (PyErr_Occurred()) SWIG_fail;
31862     }
31863     {
31864 #if wxUSE_UNICODE
31865         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31866 #else
31867         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31868 #endif
31869     }
31870     return resultobj;
31871     fail:
31872     return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_GenericDirCtrl_SetFilter(PyObject *, PyObject *args, PyObject *kwargs) {
31877     PyObject *resultobj;
31878     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31879     wxString *arg2 = 0 ;
31880     bool temp2 = false ;
31881     PyObject * obj0 = 0 ;
31882     PyObject * obj1 = 0 ;
31883     char *kwnames[] = {
31884         (char *) "self",(char *) "filter", NULL
31885     };
31886
31887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilter",kwnames,&obj0,&obj1)) goto fail;
31888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31889     if (SWIG_arg_fail(1)) SWIG_fail;
31890     {
31891         arg2 = wxString_in_helper(obj1);
31892         if (arg2 == NULL) SWIG_fail;
31893         temp2 = true;
31894     }
31895     {
31896         PyThreadState* __tstate = wxPyBeginAllowThreads();
31897         (arg1)->SetFilter((wxString const &)*arg2);
31898
31899         wxPyEndAllowThreads(__tstate);
31900         if (PyErr_Occurred()) SWIG_fail;
31901     }
31902     Py_INCREF(Py_None); resultobj = Py_None;
31903     {
31904         if (temp2)
31905         delete arg2;
31906     }
31907     return resultobj;
31908     fail:
31909     {
31910         if (temp2)
31911         delete arg2;
31912     }
31913     return NULL;
31914 }
31915
31916
31917 static PyObject *_wrap_GenericDirCtrl_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
31918     PyObject *resultobj;
31919     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31920     int result;
31921     PyObject * obj0 = 0 ;
31922     char *kwnames[] = {
31923         (char *) "self", NULL
31924     };
31925
31926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilterIndex",kwnames,&obj0)) goto fail;
31927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31928     if (SWIG_arg_fail(1)) SWIG_fail;
31929     {
31930         PyThreadState* __tstate = wxPyBeginAllowThreads();
31931         result = (int)((wxGenericDirCtrl const *)arg1)->GetFilterIndex();
31932
31933         wxPyEndAllowThreads(__tstate);
31934         if (PyErr_Occurred()) SWIG_fail;
31935     }
31936     {
31937         resultobj = SWIG_From_int((int)(result));
31938     }
31939     return resultobj;
31940     fail:
31941     return NULL;
31942 }
31943
31944
31945 static PyObject *_wrap_GenericDirCtrl_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
31946     PyObject *resultobj;
31947     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31948     int arg2 ;
31949     PyObject * obj0 = 0 ;
31950     PyObject * obj1 = 0 ;
31951     char *kwnames[] = {
31952         (char *) "self",(char *) "n", NULL
31953     };
31954
31955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
31956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31957     if (SWIG_arg_fail(1)) SWIG_fail;
31958     {
31959         arg2 = (int)(SWIG_As_int(obj1));
31960         if (SWIG_arg_fail(2)) SWIG_fail;
31961     }
31962     {
31963         PyThreadState* __tstate = wxPyBeginAllowThreads();
31964         (arg1)->SetFilterIndex(arg2);
31965
31966         wxPyEndAllowThreads(__tstate);
31967         if (PyErr_Occurred()) SWIG_fail;
31968     }
31969     Py_INCREF(Py_None); resultobj = Py_None;
31970     return resultobj;
31971     fail:
31972     return NULL;
31973 }
31974
31975
31976 static PyObject *_wrap_GenericDirCtrl_GetRootId(PyObject *, PyObject *args, PyObject *kwargs) {
31977     PyObject *resultobj;
31978     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
31979     wxTreeItemId result;
31980     PyObject * obj0 = 0 ;
31981     char *kwnames[] = {
31982         (char *) "self", NULL
31983     };
31984
31985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetRootId",kwnames,&obj0)) goto fail;
31986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
31987     if (SWIG_arg_fail(1)) SWIG_fail;
31988     {
31989         PyThreadState* __tstate = wxPyBeginAllowThreads();
31990         result = (arg1)->GetRootId();
31991
31992         wxPyEndAllowThreads(__tstate);
31993         if (PyErr_Occurred()) SWIG_fail;
31994     }
31995     {
31996         wxTreeItemId * resultptr;
31997         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
31998         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
31999     }
32000     return resultobj;
32001     fail:
32002     return NULL;
32003 }
32004
32005
32006 static PyObject *_wrap_GenericDirCtrl_GetTreeCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32007     PyObject *resultobj;
32008     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32009     wxPyTreeCtrl *result;
32010     PyObject * obj0 = 0 ;
32011     char *kwnames[] = {
32012         (char *) "self", NULL
32013     };
32014
32015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetTreeCtrl",kwnames,&obj0)) goto fail;
32016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32017     if (SWIG_arg_fail(1)) SWIG_fail;
32018     {
32019         PyThreadState* __tstate = wxPyBeginAllowThreads();
32020         result = (wxPyTreeCtrl *)((wxGenericDirCtrl const *)arg1)->GetTreeCtrl();
32021
32022         wxPyEndAllowThreads(__tstate);
32023         if (PyErr_Occurred()) SWIG_fail;
32024     }
32025     {
32026         resultobj = wxPyMake_wxObject(result, 0);
32027     }
32028     return resultobj;
32029     fail:
32030     return NULL;
32031 }
32032
32033
32034 static PyObject *_wrap_GenericDirCtrl_GetFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32035     PyObject *resultobj;
32036     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32037     wxDirFilterListCtrl *result;
32038     PyObject * obj0 = 0 ;
32039     char *kwnames[] = {
32040         (char *) "self", NULL
32041     };
32042
32043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_GetFilterListCtrl",kwnames,&obj0)) goto fail;
32044     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32045     if (SWIG_arg_fail(1)) SWIG_fail;
32046     {
32047         PyThreadState* __tstate = wxPyBeginAllowThreads();
32048         result = (wxDirFilterListCtrl *)((wxGenericDirCtrl const *)arg1)->GetFilterListCtrl();
32049
32050         wxPyEndAllowThreads(__tstate);
32051         if (PyErr_Occurred()) SWIG_fail;
32052     }
32053     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 0);
32054     return resultobj;
32055     fail:
32056     return NULL;
32057 }
32058
32059
32060 static PyObject *_wrap_GenericDirCtrl_FindChild(PyObject *, PyObject *args, PyObject *kwargs) {
32061     PyObject *resultobj;
32062     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32063     wxTreeItemId arg2 ;
32064     wxString *arg3 = 0 ;
32065     bool *arg4 = 0 ;
32066     wxTreeItemId result;
32067     bool temp3 = false ;
32068     bool temp4 ;
32069     int res4 = 0 ;
32070     PyObject * obj0 = 0 ;
32071     PyObject * obj1 = 0 ;
32072     PyObject * obj2 = 0 ;
32073     char *kwnames[] = {
32074         (char *) "self",(char *) "parentId",(char *) "path", NULL
32075     };
32076
32077     arg4 = &temp4; res4 = SWIG_NEWOBJ;
32078     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GenericDirCtrl_FindChild",kwnames,&obj0,&obj1,&obj2)) goto fail;
32079     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32080     if (SWIG_arg_fail(1)) SWIG_fail;
32081     {
32082         wxTreeItemId * argp;
32083         SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION);
32084         if (SWIG_arg_fail(2)) SWIG_fail;
32085         if (argp == NULL) {
32086             SWIG_null_ref("wxTreeItemId");
32087         }
32088         if (SWIG_arg_fail(2)) SWIG_fail;
32089         arg2 = *argp;
32090     }
32091     {
32092         arg3 = wxString_in_helper(obj2);
32093         if (arg3 == NULL) SWIG_fail;
32094         temp3 = true;
32095     }
32096     {
32097         PyThreadState* __tstate = wxPyBeginAllowThreads();
32098         result = (arg1)->FindChild(arg2,(wxString const &)*arg3,*arg4);
32099
32100         wxPyEndAllowThreads(__tstate);
32101         if (PyErr_Occurred()) SWIG_fail;
32102     }
32103     {
32104         wxTreeItemId * resultptr;
32105         resultptr = new wxTreeItemId((wxTreeItemId &)(result));
32106         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTreeItemId, 1);
32107     }
32108     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
32109     SWIG_From_bool((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_bool, 0)));
32110     {
32111         if (temp3)
32112         delete arg3;
32113     }
32114     return resultobj;
32115     fail:
32116     {
32117         if (temp3)
32118         delete arg3;
32119     }
32120     return NULL;
32121 }
32122
32123
32124 static PyObject *_wrap_GenericDirCtrl_DoResize(PyObject *, PyObject *args, PyObject *kwargs) {
32125     PyObject *resultobj;
32126     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32127     PyObject * obj0 = 0 ;
32128     char *kwnames[] = {
32129         (char *) "self", NULL
32130     };
32131
32132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_DoResize",kwnames,&obj0)) goto fail;
32133     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32134     if (SWIG_arg_fail(1)) SWIG_fail;
32135     {
32136         PyThreadState* __tstate = wxPyBeginAllowThreads();
32137         (arg1)->DoResize();
32138
32139         wxPyEndAllowThreads(__tstate);
32140         if (PyErr_Occurred()) SWIG_fail;
32141     }
32142     Py_INCREF(Py_None); resultobj = Py_None;
32143     return resultobj;
32144     fail:
32145     return NULL;
32146 }
32147
32148
32149 static PyObject *_wrap_GenericDirCtrl_ReCreateTree(PyObject *, PyObject *args, PyObject *kwargs) {
32150     PyObject *resultobj;
32151     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32152     PyObject * obj0 = 0 ;
32153     char *kwnames[] = {
32154         (char *) "self", NULL
32155     };
32156
32157     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericDirCtrl_ReCreateTree",kwnames,&obj0)) goto fail;
32158     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32159     if (SWIG_arg_fail(1)) SWIG_fail;
32160     {
32161         PyThreadState* __tstate = wxPyBeginAllowThreads();
32162         (arg1)->ReCreateTree();
32163
32164         wxPyEndAllowThreads(__tstate);
32165         if (PyErr_Occurred()) SWIG_fail;
32166     }
32167     Py_INCREF(Py_None); resultobj = Py_None;
32168     return resultobj;
32169     fail:
32170     return NULL;
32171 }
32172
32173
32174 static PyObject * GenericDirCtrl_swigregister(PyObject *, PyObject *args) {
32175     PyObject *obj;
32176     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32177     SWIG_TypeClientData(SWIGTYPE_p_wxGenericDirCtrl, obj);
32178     Py_INCREF(obj);
32179     return Py_BuildValue((char *)"");
32180 }
32181 static PyObject *_wrap_new_DirFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32182     PyObject *resultobj;
32183     wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
32184     int arg2 = (int) (int)-1 ;
32185     wxPoint const &arg3_defvalue = wxDefaultPosition ;
32186     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32187     wxSize const &arg4_defvalue = wxDefaultSize ;
32188     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32189     long arg5 = (long) 0 ;
32190     wxDirFilterListCtrl *result;
32191     wxPoint temp3 ;
32192     wxSize temp4 ;
32193     PyObject * obj0 = 0 ;
32194     PyObject * obj1 = 0 ;
32195     PyObject * obj2 = 0 ;
32196     PyObject * obj3 = 0 ;
32197     PyObject * obj4 = 0 ;
32198     char *kwnames[] = {
32199         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
32200     };
32201
32202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_DirFilterListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32203     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32204     if (SWIG_arg_fail(1)) SWIG_fail;
32205     if (obj1) {
32206         {
32207             arg2 = (int const)(SWIG_As_int(obj1));
32208             if (SWIG_arg_fail(2)) SWIG_fail;
32209         }
32210     }
32211     if (obj2) {
32212         {
32213             arg3 = &temp3;
32214             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32215         }
32216     }
32217     if (obj3) {
32218         {
32219             arg4 = &temp4;
32220             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32221         }
32222     }
32223     if (obj4) {
32224         {
32225             arg5 = (long)(SWIG_As_long(obj4));
32226             if (SWIG_arg_fail(5)) SWIG_fail;
32227         }
32228     }
32229     {
32230         if (!wxPyCheckForApp()) SWIG_fail;
32231         PyThreadState* __tstate = wxPyBeginAllowThreads();
32232         result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
32233
32234         wxPyEndAllowThreads(__tstate);
32235         if (PyErr_Occurred()) SWIG_fail;
32236     }
32237     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 1);
32238     return resultobj;
32239     fail:
32240     return NULL;
32241 }
32242
32243
32244 static PyObject *_wrap_new_PreDirFilterListCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
32245     PyObject *resultobj;
32246     wxDirFilterListCtrl *result;
32247     char *kwnames[] = {
32248         NULL
32249     };
32250
32251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDirFilterListCtrl",kwnames)) goto fail;
32252     {
32253         if (!wxPyCheckForApp()) SWIG_fail;
32254         PyThreadState* __tstate = wxPyBeginAllowThreads();
32255         result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl();
32256
32257         wxPyEndAllowThreads(__tstate);
32258         if (PyErr_Occurred()) SWIG_fail;
32259     }
32260     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirFilterListCtrl, 1);
32261     return resultobj;
32262     fail:
32263     return NULL;
32264 }
32265
32266
32267 static PyObject *_wrap_DirFilterListCtrl_Create(PyObject *, PyObject *args, PyObject *kwargs) {
32268     PyObject *resultobj;
32269     wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
32270     wxGenericDirCtrl *arg2 = (wxGenericDirCtrl *) 0 ;
32271     int arg3 = (int) (int)-1 ;
32272     wxPoint const &arg4_defvalue = wxDefaultPosition ;
32273     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32274     wxSize const &arg5_defvalue = wxDefaultSize ;
32275     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32276     long arg6 = (long) 0 ;
32277     bool result;
32278     wxPoint temp4 ;
32279     wxSize temp5 ;
32280     PyObject * obj0 = 0 ;
32281     PyObject * obj1 = 0 ;
32282     PyObject * obj2 = 0 ;
32283     PyObject * obj3 = 0 ;
32284     PyObject * obj4 = 0 ;
32285     PyObject * obj5 = 0 ;
32286     char *kwnames[] = {
32287         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
32288     };
32289
32290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:DirFilterListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32291     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_EXCEPTION | 0);
32292     if (SWIG_arg_fail(1)) SWIG_fail;
32293     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_EXCEPTION | 0);
32294     if (SWIG_arg_fail(2)) SWIG_fail;
32295     if (obj2) {
32296         {
32297             arg3 = (int const)(SWIG_As_int(obj2));
32298             if (SWIG_arg_fail(3)) SWIG_fail;
32299         }
32300     }
32301     if (obj3) {
32302         {
32303             arg4 = &temp4;
32304             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32305         }
32306     }
32307     if (obj4) {
32308         {
32309             arg5 = &temp5;
32310             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32311         }
32312     }
32313     if (obj5) {
32314         {
32315             arg6 = (long)(SWIG_As_long(obj5));
32316             if (SWIG_arg_fail(6)) SWIG_fail;
32317         }
32318     }
32319     {
32320         PyThreadState* __tstate = wxPyBeginAllowThreads();
32321         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
32322
32323         wxPyEndAllowThreads(__tstate);
32324         if (PyErr_Occurred()) SWIG_fail;
32325     }
32326     {
32327         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32328     }
32329     return resultobj;
32330     fail:
32331     return NULL;
32332 }
32333
32334
32335 static PyObject *_wrap_DirFilterListCtrl_FillFilterList(PyObject *, PyObject *args, PyObject *kwargs) {
32336     PyObject *resultobj;
32337     wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
32338     wxString *arg2 = 0 ;
32339     int arg3 ;
32340     bool temp2 = false ;
32341     PyObject * obj0 = 0 ;
32342     PyObject * obj1 = 0 ;
32343     PyObject * obj2 = 0 ;
32344     char *kwnames[] = {
32345         (char *) "self",(char *) "filter",(char *) "defaultFilter", NULL
32346     };
32347
32348     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DirFilterListCtrl_FillFilterList",kwnames,&obj0,&obj1,&obj2)) goto fail;
32349     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_EXCEPTION | 0);
32350     if (SWIG_arg_fail(1)) SWIG_fail;
32351     {
32352         arg2 = wxString_in_helper(obj1);
32353         if (arg2 == NULL) SWIG_fail;
32354         temp2 = true;
32355     }
32356     {
32357         arg3 = (int)(SWIG_As_int(obj2));
32358         if (SWIG_arg_fail(3)) SWIG_fail;
32359     }
32360     {
32361         PyThreadState* __tstate = wxPyBeginAllowThreads();
32362         (arg1)->FillFilterList((wxString const &)*arg2,arg3);
32363
32364         wxPyEndAllowThreads(__tstate);
32365         if (PyErr_Occurred()) SWIG_fail;
32366     }
32367     Py_INCREF(Py_None); resultobj = Py_None;
32368     {
32369         if (temp2)
32370         delete arg2;
32371     }
32372     return resultobj;
32373     fail:
32374     {
32375         if (temp2)
32376         delete arg2;
32377     }
32378     return NULL;
32379 }
32380
32381
32382 static PyObject * DirFilterListCtrl_swigregister(PyObject *, PyObject *args) {
32383     PyObject *obj;
32384     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32385     SWIG_TypeClientData(SWIGTYPE_p_wxDirFilterListCtrl, obj);
32386     Py_INCREF(obj);
32387     return Py_BuildValue((char *)"");
32388 }
32389 static PyObject *_wrap_new_PyControl(PyObject *, PyObject *args, PyObject *kwargs) {
32390     PyObject *resultobj;
32391     wxWindow *arg1 = (wxWindow *) 0 ;
32392     int arg2 = (int) (int)-1 ;
32393     wxPoint const &arg3_defvalue = wxDefaultPosition ;
32394     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32395     wxSize const &arg4_defvalue = wxDefaultSize ;
32396     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32397     long arg5 = (long) 0 ;
32398     wxValidator const &arg6_defvalue = wxDefaultValidator ;
32399     wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
32400     wxString const &arg7_defvalue = wxPyControlNameStr ;
32401     wxString *arg7 = (wxString *) &arg7_defvalue ;
32402     wxPyControl *result;
32403     wxPoint temp3 ;
32404     wxSize temp4 ;
32405     bool temp7 = false ;
32406     PyObject * obj0 = 0 ;
32407     PyObject * obj1 = 0 ;
32408     PyObject * obj2 = 0 ;
32409     PyObject * obj3 = 0 ;
32410     PyObject * obj4 = 0 ;
32411     PyObject * obj5 = 0 ;
32412     PyObject * obj6 = 0 ;
32413     char *kwnames[] = {
32414         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
32415     };
32416
32417     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_PyControl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
32418     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32419     if (SWIG_arg_fail(1)) SWIG_fail;
32420     if (obj1) {
32421         {
32422             arg2 = (int const)(SWIG_As_int(obj1));
32423             if (SWIG_arg_fail(2)) SWIG_fail;
32424         }
32425     }
32426     if (obj2) {
32427         {
32428             arg3 = &temp3;
32429             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32430         }
32431     }
32432     if (obj3) {
32433         {
32434             arg4 = &temp4;
32435             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32436         }
32437     }
32438     if (obj4) {
32439         {
32440             arg5 = (long)(SWIG_As_long(obj4));
32441             if (SWIG_arg_fail(5)) SWIG_fail;
32442         }
32443     }
32444     if (obj5) {
32445         {
32446             SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32447             if (SWIG_arg_fail(6)) SWIG_fail;
32448             if (arg6 == NULL) {
32449                 SWIG_null_ref("wxValidator");
32450             }
32451             if (SWIG_arg_fail(6)) SWIG_fail;
32452         }
32453     }
32454     if (obj6) {
32455         {
32456             arg7 = wxString_in_helper(obj6);
32457             if (arg7 == NULL) SWIG_fail;
32458             temp7 = true;
32459         }
32460     }
32461     {
32462         if (!wxPyCheckForApp()) SWIG_fail;
32463         PyThreadState* __tstate = wxPyBeginAllowThreads();
32464         result = (wxPyControl *)new wxPyControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
32465
32466         wxPyEndAllowThreads(__tstate);
32467         if (PyErr_Occurred()) SWIG_fail;
32468     }
32469     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyControl, 1);
32470     {
32471         if (temp7)
32472         delete arg7;
32473     }
32474     return resultobj;
32475     fail:
32476     {
32477         if (temp7)
32478         delete arg7;
32479     }
32480     return NULL;
32481 }
32482
32483
32484 static PyObject *_wrap_new_PrePyControl(PyObject *, PyObject *args, PyObject *kwargs) {
32485     PyObject *resultobj;
32486     wxPyControl *result;
32487     char *kwnames[] = {
32488         NULL
32489     };
32490
32491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyControl",kwnames)) goto fail;
32492     {
32493         if (!wxPyCheckForApp()) SWIG_fail;
32494         PyThreadState* __tstate = wxPyBeginAllowThreads();
32495         result = (wxPyControl *)new wxPyControl();
32496
32497         wxPyEndAllowThreads(__tstate);
32498         if (PyErr_Occurred()) SWIG_fail;
32499     }
32500     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyControl, 1);
32501     return resultobj;
32502     fail:
32503     return NULL;
32504 }
32505
32506
32507 static PyObject *_wrap_PyControl__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32508     PyObject *resultobj;
32509     wxPyControl *arg1 = (wxPyControl *) 0 ;
32510     PyObject *arg2 = (PyObject *) 0 ;
32511     PyObject *arg3 = (PyObject *) 0 ;
32512     PyObject * obj0 = 0 ;
32513     PyObject * obj1 = 0 ;
32514     PyObject * obj2 = 0 ;
32515     char *kwnames[] = {
32516         (char *) "self",(char *) "self",(char *) "_class", NULL
32517     };
32518
32519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
32520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32521     if (SWIG_arg_fail(1)) SWIG_fail;
32522     arg2 = obj1;
32523     arg3 = obj2;
32524     {
32525         PyThreadState* __tstate = wxPyBeginAllowThreads();
32526         (arg1)->_setCallbackInfo(arg2,arg3);
32527
32528         wxPyEndAllowThreads(__tstate);
32529         if (PyErr_Occurred()) SWIG_fail;
32530     }
32531     Py_INCREF(Py_None); resultobj = Py_None;
32532     return resultobj;
32533     fail:
32534     return NULL;
32535 }
32536
32537
32538 static PyObject *_wrap_PyControl_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
32539     PyObject *resultobj;
32540     wxPyControl *arg1 = (wxPyControl *) 0 ;
32541     wxSize *arg2 = 0 ;
32542     wxSize temp2 ;
32543     PyObject * obj0 = 0 ;
32544     PyObject * obj1 = 0 ;
32545     char *kwnames[] = {
32546         (char *) "self",(char *) "size", NULL
32547     };
32548
32549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
32550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32551     if (SWIG_arg_fail(1)) SWIG_fail;
32552     {
32553         arg2 = &temp2;
32554         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32555     }
32556     {
32557         PyThreadState* __tstate = wxPyBeginAllowThreads();
32558         (arg1)->SetBestSize((wxSize const &)*arg2);
32559
32560         wxPyEndAllowThreads(__tstate);
32561         if (PyErr_Occurred()) SWIG_fail;
32562     }
32563     Py_INCREF(Py_None); resultobj = Py_None;
32564     return resultobj;
32565     fail:
32566     return NULL;
32567 }
32568
32569
32570 static PyObject *_wrap_PyControl_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32571     PyObject *resultobj;
32572     wxPyControl *arg1 = (wxPyControl *) 0 ;
32573     int arg2 ;
32574     int arg3 ;
32575     int arg4 ;
32576     int arg5 ;
32577     PyObject * obj0 = 0 ;
32578     PyObject * obj1 = 0 ;
32579     PyObject * obj2 = 0 ;
32580     PyObject * obj3 = 0 ;
32581     PyObject * obj4 = 0 ;
32582     char *kwnames[] = {
32583         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
32584     };
32585
32586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyControl_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32588     if (SWIG_arg_fail(1)) SWIG_fail;
32589     {
32590         arg2 = (int)(SWIG_As_int(obj1));
32591         if (SWIG_arg_fail(2)) SWIG_fail;
32592     }
32593     {
32594         arg3 = (int)(SWIG_As_int(obj2));
32595         if (SWIG_arg_fail(3)) SWIG_fail;
32596     }
32597     {
32598         arg4 = (int)(SWIG_As_int(obj3));
32599         if (SWIG_arg_fail(4)) SWIG_fail;
32600     }
32601     {
32602         arg5 = (int)(SWIG_As_int(obj4));
32603         if (SWIG_arg_fail(5)) SWIG_fail;
32604     }
32605     {
32606         PyThreadState* __tstate = wxPyBeginAllowThreads();
32607         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
32608
32609         wxPyEndAllowThreads(__tstate);
32610         if (PyErr_Occurred()) SWIG_fail;
32611     }
32612     Py_INCREF(Py_None); resultobj = Py_None;
32613     return resultobj;
32614     fail:
32615     return NULL;
32616 }
32617
32618
32619 static PyObject *_wrap_PyControl_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
32620     PyObject *resultobj;
32621     wxPyControl *arg1 = (wxPyControl *) 0 ;
32622     int arg2 ;
32623     int arg3 ;
32624     int arg4 ;
32625     int arg5 ;
32626     int arg6 = (int) wxSIZE_AUTO ;
32627     PyObject * obj0 = 0 ;
32628     PyObject * obj1 = 0 ;
32629     PyObject * obj2 = 0 ;
32630     PyObject * obj3 = 0 ;
32631     PyObject * obj4 = 0 ;
32632     PyObject * obj5 = 0 ;
32633     char *kwnames[] = {
32634         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
32635     };
32636
32637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyControl_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32639     if (SWIG_arg_fail(1)) SWIG_fail;
32640     {
32641         arg2 = (int)(SWIG_As_int(obj1));
32642         if (SWIG_arg_fail(2)) SWIG_fail;
32643     }
32644     {
32645         arg3 = (int)(SWIG_As_int(obj2));
32646         if (SWIG_arg_fail(3)) SWIG_fail;
32647     }
32648     {
32649         arg4 = (int)(SWIG_As_int(obj3));
32650         if (SWIG_arg_fail(4)) SWIG_fail;
32651     }
32652     {
32653         arg5 = (int)(SWIG_As_int(obj4));
32654         if (SWIG_arg_fail(5)) SWIG_fail;
32655     }
32656     if (obj5) {
32657         {
32658             arg6 = (int)(SWIG_As_int(obj5));
32659             if (SWIG_arg_fail(6)) SWIG_fail;
32660         }
32661     }
32662     {
32663         PyThreadState* __tstate = wxPyBeginAllowThreads();
32664         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
32665
32666         wxPyEndAllowThreads(__tstate);
32667         if (PyErr_Occurred()) SWIG_fail;
32668     }
32669     Py_INCREF(Py_None); resultobj = Py_None;
32670     return resultobj;
32671     fail:
32672     return NULL;
32673 }
32674
32675
32676 static PyObject *_wrap_PyControl_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
32677     PyObject *resultobj;
32678     wxPyControl *arg1 = (wxPyControl *) 0 ;
32679     int arg2 ;
32680     int arg3 ;
32681     PyObject * obj0 = 0 ;
32682     PyObject * obj1 = 0 ;
32683     PyObject * obj2 = 0 ;
32684     char *kwnames[] = {
32685         (char *) "self",(char *) "width",(char *) "height", NULL
32686     };
32687
32688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
32689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32690     if (SWIG_arg_fail(1)) SWIG_fail;
32691     {
32692         arg2 = (int)(SWIG_As_int(obj1));
32693         if (SWIG_arg_fail(2)) SWIG_fail;
32694     }
32695     {
32696         arg3 = (int)(SWIG_As_int(obj2));
32697         if (SWIG_arg_fail(3)) SWIG_fail;
32698     }
32699     {
32700         PyThreadState* __tstate = wxPyBeginAllowThreads();
32701         (arg1)->base_DoSetClientSize(arg2,arg3);
32702
32703         wxPyEndAllowThreads(__tstate);
32704         if (PyErr_Occurred()) SWIG_fail;
32705     }
32706     Py_INCREF(Py_None); resultobj = Py_None;
32707     return resultobj;
32708     fail:
32709     return NULL;
32710 }
32711
32712
32713 static PyObject *_wrap_PyControl_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
32714     PyObject *resultobj;
32715     wxPyControl *arg1 = (wxPyControl *) 0 ;
32716     int arg2 ;
32717     int arg3 ;
32718     PyObject * obj0 = 0 ;
32719     PyObject * obj1 = 0 ;
32720     PyObject * obj2 = 0 ;
32721     char *kwnames[] = {
32722         (char *) "self",(char *) "x",(char *) "y", NULL
32723     };
32724
32725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
32726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32727     if (SWIG_arg_fail(1)) SWIG_fail;
32728     {
32729         arg2 = (int)(SWIG_As_int(obj1));
32730         if (SWIG_arg_fail(2)) SWIG_fail;
32731     }
32732     {
32733         arg3 = (int)(SWIG_As_int(obj2));
32734         if (SWIG_arg_fail(3)) SWIG_fail;
32735     }
32736     {
32737         PyThreadState* __tstate = wxPyBeginAllowThreads();
32738         (arg1)->base_DoSetVirtualSize(arg2,arg3);
32739
32740         wxPyEndAllowThreads(__tstate);
32741         if (PyErr_Occurred()) SWIG_fail;
32742     }
32743     Py_INCREF(Py_None); resultobj = Py_None;
32744     return resultobj;
32745     fail:
32746     return NULL;
32747 }
32748
32749
32750 static PyObject *_wrap_PyControl_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
32751     PyObject *resultobj;
32752     wxPyControl *arg1 = (wxPyControl *) 0 ;
32753     int *arg2 = (int *) 0 ;
32754     int *arg3 = (int *) 0 ;
32755     int temp2 ;
32756     int res2 = 0 ;
32757     int temp3 ;
32758     int res3 = 0 ;
32759     PyObject * obj0 = 0 ;
32760     char *kwnames[] = {
32761         (char *) "self", NULL
32762     };
32763
32764     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32765     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32766     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetSize",kwnames,&obj0)) goto fail;
32767     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32768     if (SWIG_arg_fail(1)) SWIG_fail;
32769     {
32770         PyThreadState* __tstate = wxPyBeginAllowThreads();
32771         ((wxPyControl const *)arg1)->base_DoGetSize(arg2,arg3);
32772
32773         wxPyEndAllowThreads(__tstate);
32774         if (PyErr_Occurred()) SWIG_fail;
32775     }
32776     Py_INCREF(Py_None); resultobj = Py_None;
32777     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32778     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32779     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32780     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32781     return resultobj;
32782     fail:
32783     return NULL;
32784 }
32785
32786
32787 static PyObject *_wrap_PyControl_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
32788     PyObject *resultobj;
32789     wxPyControl *arg1 = (wxPyControl *) 0 ;
32790     int *arg2 = (int *) 0 ;
32791     int *arg3 = (int *) 0 ;
32792     int temp2 ;
32793     int res2 = 0 ;
32794     int temp3 ;
32795     int res3 = 0 ;
32796     PyObject * obj0 = 0 ;
32797     char *kwnames[] = {
32798         (char *) "self", NULL
32799     };
32800
32801     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32802     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetClientSize",kwnames,&obj0)) goto fail;
32804     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32805     if (SWIG_arg_fail(1)) SWIG_fail;
32806     {
32807         PyThreadState* __tstate = wxPyBeginAllowThreads();
32808         ((wxPyControl const *)arg1)->base_DoGetClientSize(arg2,arg3);
32809
32810         wxPyEndAllowThreads(__tstate);
32811         if (PyErr_Occurred()) SWIG_fail;
32812     }
32813     Py_INCREF(Py_None); resultobj = Py_None;
32814     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32815     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32816     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32817     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32818     return resultobj;
32819     fail:
32820     return NULL;
32821 }
32822
32823
32824 static PyObject *_wrap_PyControl_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
32825     PyObject *resultobj;
32826     wxPyControl *arg1 = (wxPyControl *) 0 ;
32827     int *arg2 = (int *) 0 ;
32828     int *arg3 = (int *) 0 ;
32829     int temp2 ;
32830     int res2 = 0 ;
32831     int temp3 ;
32832     int res3 = 0 ;
32833     PyObject * obj0 = 0 ;
32834     char *kwnames[] = {
32835         (char *) "self", NULL
32836     };
32837
32838     arg2 = &temp2; res2 = SWIG_NEWOBJ;
32839     arg3 = &temp3; res3 = SWIG_NEWOBJ;
32840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetPosition",kwnames,&obj0)) goto fail;
32841     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32842     if (SWIG_arg_fail(1)) SWIG_fail;
32843     {
32844         PyThreadState* __tstate = wxPyBeginAllowThreads();
32845         ((wxPyControl const *)arg1)->base_DoGetPosition(arg2,arg3);
32846
32847         wxPyEndAllowThreads(__tstate);
32848         if (PyErr_Occurred()) SWIG_fail;
32849     }
32850     Py_INCREF(Py_None); resultobj = Py_None;
32851     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
32852     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
32853     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
32854     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
32855     return resultobj;
32856     fail:
32857     return NULL;
32858 }
32859
32860
32861 static PyObject *_wrap_PyControl_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
32862     PyObject *resultobj;
32863     wxPyControl *arg1 = (wxPyControl *) 0 ;
32864     wxSize result;
32865     PyObject * obj0 = 0 ;
32866     char *kwnames[] = {
32867         (char *) "self", NULL
32868     };
32869
32870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
32871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32872     if (SWIG_arg_fail(1)) SWIG_fail;
32873     {
32874         PyThreadState* __tstate = wxPyBeginAllowThreads();
32875         result = ((wxPyControl const *)arg1)->base_DoGetVirtualSize();
32876
32877         wxPyEndAllowThreads(__tstate);
32878         if (PyErr_Occurred()) SWIG_fail;
32879     }
32880     {
32881         wxSize * resultptr;
32882         resultptr = new wxSize((wxSize &)(result));
32883         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
32884     }
32885     return resultobj;
32886     fail:
32887     return NULL;
32888 }
32889
32890
32891 static PyObject *_wrap_PyControl_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
32892     PyObject *resultobj;
32893     wxPyControl *arg1 = (wxPyControl *) 0 ;
32894     wxSize result;
32895     PyObject * obj0 = 0 ;
32896     char *kwnames[] = {
32897         (char *) "self", NULL
32898     };
32899
32900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_DoGetBestSize",kwnames,&obj0)) goto fail;
32901     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32902     if (SWIG_arg_fail(1)) SWIG_fail;
32903     {
32904         PyThreadState* __tstate = wxPyBeginAllowThreads();
32905         result = ((wxPyControl const *)arg1)->base_DoGetBestSize();
32906
32907         wxPyEndAllowThreads(__tstate);
32908         if (PyErr_Occurred()) SWIG_fail;
32909     }
32910     {
32911         wxSize * resultptr;
32912         resultptr = new wxSize((wxSize &)(result));
32913         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
32914     }
32915     return resultobj;
32916     fail:
32917     return NULL;
32918 }
32919
32920
32921 static PyObject *_wrap_PyControl_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
32922     PyObject *resultobj;
32923     wxPyControl *arg1 = (wxPyControl *) 0 ;
32924     PyObject * obj0 = 0 ;
32925     char *kwnames[] = {
32926         (char *) "self", NULL
32927     };
32928
32929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_InitDialog",kwnames,&obj0)) goto fail;
32930     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32931     if (SWIG_arg_fail(1)) SWIG_fail;
32932     {
32933         PyThreadState* __tstate = wxPyBeginAllowThreads();
32934         (arg1)->base_InitDialog();
32935
32936         wxPyEndAllowThreads(__tstate);
32937         if (PyErr_Occurred()) SWIG_fail;
32938     }
32939     Py_INCREF(Py_None); resultobj = Py_None;
32940     return resultobj;
32941     fail:
32942     return NULL;
32943 }
32944
32945
32946 static PyObject *_wrap_PyControl_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32947     PyObject *resultobj;
32948     wxPyControl *arg1 = (wxPyControl *) 0 ;
32949     bool result;
32950     PyObject * obj0 = 0 ;
32951     char *kwnames[] = {
32952         (char *) "self", NULL
32953     };
32954
32955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
32956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32957     if (SWIG_arg_fail(1)) SWIG_fail;
32958     {
32959         PyThreadState* __tstate = wxPyBeginAllowThreads();
32960         result = (bool)(arg1)->base_TransferDataToWindow();
32961
32962         wxPyEndAllowThreads(__tstate);
32963         if (PyErr_Occurred()) SWIG_fail;
32964     }
32965     {
32966         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32967     }
32968     return resultobj;
32969     fail:
32970     return NULL;
32971 }
32972
32973
32974 static PyObject *_wrap_PyControl_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32975     PyObject *resultobj;
32976     wxPyControl *arg1 = (wxPyControl *) 0 ;
32977     bool result;
32978     PyObject * obj0 = 0 ;
32979     char *kwnames[] = {
32980         (char *) "self", NULL
32981     };
32982
32983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
32984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
32985     if (SWIG_arg_fail(1)) SWIG_fail;
32986     {
32987         PyThreadState* __tstate = wxPyBeginAllowThreads();
32988         result = (bool)(arg1)->base_TransferDataFromWindow();
32989
32990         wxPyEndAllowThreads(__tstate);
32991         if (PyErr_Occurred()) SWIG_fail;
32992     }
32993     {
32994         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32995     }
32996     return resultobj;
32997     fail:
32998     return NULL;
32999 }
33000
33001
33002 static PyObject *_wrap_PyControl_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33003     PyObject *resultobj;
33004     wxPyControl *arg1 = (wxPyControl *) 0 ;
33005     bool result;
33006     PyObject * obj0 = 0 ;
33007     char *kwnames[] = {
33008         (char *) "self", NULL
33009     };
33010
33011     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_Validate",kwnames,&obj0)) goto fail;
33012     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33013     if (SWIG_arg_fail(1)) SWIG_fail;
33014     {
33015         PyThreadState* __tstate = wxPyBeginAllowThreads();
33016         result = (bool)(arg1)->base_Validate();
33017
33018         wxPyEndAllowThreads(__tstate);
33019         if (PyErr_Occurred()) SWIG_fail;
33020     }
33021     {
33022         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33023     }
33024     return resultobj;
33025     fail:
33026     return NULL;
33027 }
33028
33029
33030 static PyObject *_wrap_PyControl_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
33031     PyObject *resultobj;
33032     wxPyControl *arg1 = (wxPyControl *) 0 ;
33033     bool result;
33034     PyObject * obj0 = 0 ;
33035     char *kwnames[] = {
33036         (char *) "self", NULL
33037     };
33038
33039     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_AcceptsFocus",kwnames,&obj0)) goto fail;
33040     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33041     if (SWIG_arg_fail(1)) SWIG_fail;
33042     {
33043         PyThreadState* __tstate = wxPyBeginAllowThreads();
33044         result = (bool)((wxPyControl const *)arg1)->base_AcceptsFocus();
33045
33046         wxPyEndAllowThreads(__tstate);
33047         if (PyErr_Occurred()) SWIG_fail;
33048     }
33049     {
33050         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33051     }
33052     return resultobj;
33053     fail:
33054     return NULL;
33055 }
33056
33057
33058 static PyObject *_wrap_PyControl_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
33059     PyObject *resultobj;
33060     wxPyControl *arg1 = (wxPyControl *) 0 ;
33061     bool result;
33062     PyObject * obj0 = 0 ;
33063     char *kwnames[] = {
33064         (char *) "self", NULL
33065     };
33066
33067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
33068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33069     if (SWIG_arg_fail(1)) SWIG_fail;
33070     {
33071         PyThreadState* __tstate = wxPyBeginAllowThreads();
33072         result = (bool)((wxPyControl const *)arg1)->base_AcceptsFocusFromKeyboard();
33073
33074         wxPyEndAllowThreads(__tstate);
33075         if (PyErr_Occurred()) SWIG_fail;
33076     }
33077     {
33078         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33079     }
33080     return resultobj;
33081     fail:
33082     return NULL;
33083 }
33084
33085
33086 static PyObject *_wrap_PyControl_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
33087     PyObject *resultobj;
33088     wxPyControl *arg1 = (wxPyControl *) 0 ;
33089     wxSize result;
33090     PyObject * obj0 = 0 ;
33091     char *kwnames[] = {
33092         (char *) "self", NULL
33093     };
33094
33095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_GetMaxSize",kwnames,&obj0)) goto fail;
33096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33097     if (SWIG_arg_fail(1)) SWIG_fail;
33098     {
33099         PyThreadState* __tstate = wxPyBeginAllowThreads();
33100         result = ((wxPyControl const *)arg1)->base_GetMaxSize();
33101
33102         wxPyEndAllowThreads(__tstate);
33103         if (PyErr_Occurred()) SWIG_fail;
33104     }
33105     {
33106         wxSize * resultptr;
33107         resultptr = new wxSize((wxSize &)(result));
33108         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
33109     }
33110     return resultobj;
33111     fail:
33112     return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_PyControl_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
33117     PyObject *resultobj;
33118     wxPyControl *arg1 = (wxPyControl *) 0 ;
33119     wxWindow *arg2 = (wxWindow *) 0 ;
33120     PyObject * obj0 = 0 ;
33121     PyObject * obj1 = 0 ;
33122     char *kwnames[] = {
33123         (char *) "self",(char *) "child", NULL
33124     };
33125
33126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
33127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33128     if (SWIG_arg_fail(1)) SWIG_fail;
33129     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33130     if (SWIG_arg_fail(2)) SWIG_fail;
33131     {
33132         PyThreadState* __tstate = wxPyBeginAllowThreads();
33133         (arg1)->base_AddChild(arg2);
33134
33135         wxPyEndAllowThreads(__tstate);
33136         if (PyErr_Occurred()) SWIG_fail;
33137     }
33138     Py_INCREF(Py_None); resultobj = Py_None;
33139     return resultobj;
33140     fail:
33141     return NULL;
33142 }
33143
33144
33145 static PyObject *_wrap_PyControl_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
33146     PyObject *resultobj;
33147     wxPyControl *arg1 = (wxPyControl *) 0 ;
33148     wxWindow *arg2 = (wxWindow *) 0 ;
33149     PyObject * obj0 = 0 ;
33150     PyObject * obj1 = 0 ;
33151     char *kwnames[] = {
33152         (char *) "self",(char *) "child", NULL
33153     };
33154
33155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
33156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33157     if (SWIG_arg_fail(1)) SWIG_fail;
33158     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33159     if (SWIG_arg_fail(2)) SWIG_fail;
33160     {
33161         PyThreadState* __tstate = wxPyBeginAllowThreads();
33162         (arg1)->base_RemoveChild(arg2);
33163
33164         wxPyEndAllowThreads(__tstate);
33165         if (PyErr_Occurred()) SWIG_fail;
33166     }
33167     Py_INCREF(Py_None); resultobj = Py_None;
33168     return resultobj;
33169     fail:
33170     return NULL;
33171 }
33172
33173
33174 static PyObject *_wrap_PyControl_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
33175     PyObject *resultobj;
33176     wxPyControl *arg1 = (wxPyControl *) 0 ;
33177     bool result;
33178     PyObject * obj0 = 0 ;
33179     char *kwnames[] = {
33180         (char *) "self", NULL
33181     };
33182
33183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
33184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33185     if (SWIG_arg_fail(1)) SWIG_fail;
33186     {
33187         PyThreadState* __tstate = wxPyBeginAllowThreads();
33188         result = (bool)((wxPyControl const *)arg1)->base_ShouldInheritColours();
33189
33190         wxPyEndAllowThreads(__tstate);
33191         if (PyErr_Occurred()) SWIG_fail;
33192     }
33193     {
33194         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33195     }
33196     return resultobj;
33197     fail:
33198     return NULL;
33199 }
33200
33201
33202 static PyObject *_wrap_PyControl_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
33203     PyObject *resultobj;
33204     wxPyControl *arg1 = (wxPyControl *) 0 ;
33205     wxColour *arg2 = 0 ;
33206     wxColour temp2 ;
33207     PyObject * obj0 = 0 ;
33208     PyObject * obj1 = 0 ;
33209     char *kwnames[] = {
33210         (char *) "self",(char *) "c", NULL
33211     };
33212
33213     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
33214     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33215     if (SWIG_arg_fail(1)) SWIG_fail;
33216     {
33217         arg2 = &temp2;
33218         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
33219     }
33220     {
33221         PyThreadState* __tstate = wxPyBeginAllowThreads();
33222         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
33223
33224         wxPyEndAllowThreads(__tstate);
33225         if (PyErr_Occurred()) SWIG_fail;
33226     }
33227     Py_INCREF(Py_None); resultobj = Py_None;
33228     return resultobj;
33229     fail:
33230     return NULL;
33231 }
33232
33233
33234 static PyObject *_wrap_PyControl_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
33235     PyObject *resultobj;
33236     wxPyControl *arg1 = (wxPyControl *) 0 ;
33237     wxVisualAttributes result;
33238     PyObject * obj0 = 0 ;
33239     char *kwnames[] = {
33240         (char *) "self", NULL
33241     };
33242
33243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyControl_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
33244     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyControl, SWIG_POINTER_EXCEPTION | 0);
33245     if (SWIG_arg_fail(1)) SWIG_fail;
33246     {
33247         PyThreadState* __tstate = wxPyBeginAllowThreads();
33248         result = (arg1)->base_GetDefaultAttributes();
33249
33250         wxPyEndAllowThreads(__tstate);
33251         if (PyErr_Occurred()) SWIG_fail;
33252     }
33253     {
33254         wxVisualAttributes * resultptr;
33255         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
33256         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
33257     }
33258     return resultobj;
33259     fail:
33260     return NULL;
33261 }
33262
33263
33264 static PyObject * PyControl_swigregister(PyObject *, PyObject *args) {
33265     PyObject *obj;
33266     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33267     SWIG_TypeClientData(SWIGTYPE_p_wxPyControl, obj);
33268     Py_INCREF(obj);
33269     return Py_BuildValue((char *)"");
33270 }
33271 static PyObject *_wrap_new_HelpEvent(PyObject *, PyObject *args, PyObject *kwargs) {
33272     PyObject *resultobj;
33273     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
33274     int arg2 = (int) 0 ;
33275     wxPoint const &arg3_defvalue = wxDefaultPosition ;
33276     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33277     wxHelpEvent *result;
33278     wxPoint temp3 ;
33279     PyObject * obj0 = 0 ;
33280     PyObject * obj1 = 0 ;
33281     PyObject * obj2 = 0 ;
33282     char *kwnames[] = {
33283         (char *) "type",(char *) "winid",(char *) "pt", NULL
33284     };
33285
33286     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_HelpEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
33287     if (obj0) {
33288         {
33289             arg1 = (wxEventType)(SWIG_As_int(obj0));
33290             if (SWIG_arg_fail(1)) SWIG_fail;
33291         }
33292     }
33293     if (obj1) {
33294         {
33295             arg2 = (int)(SWIG_As_int(obj1));
33296             if (SWIG_arg_fail(2)) SWIG_fail;
33297         }
33298     }
33299     if (obj2) {
33300         {
33301             arg3 = &temp3;
33302             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33303         }
33304     }
33305     {
33306         PyThreadState* __tstate = wxPyBeginAllowThreads();
33307         result = (wxHelpEvent *)new wxHelpEvent(arg1,arg2,(wxPoint const &)*arg3);
33308
33309         wxPyEndAllowThreads(__tstate);
33310         if (PyErr_Occurred()) SWIG_fail;
33311     }
33312     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpEvent, 1);
33313     return resultobj;
33314     fail:
33315     return NULL;
33316 }
33317
33318
33319 static PyObject *_wrap_HelpEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33320     PyObject *resultobj;
33321     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33322     wxPoint result;
33323     PyObject * obj0 = 0 ;
33324     char *kwnames[] = {
33325         (char *) "self", NULL
33326     };
33327
33328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetPosition",kwnames,&obj0)) goto fail;
33329     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33330     if (SWIG_arg_fail(1)) SWIG_fail;
33331     {
33332         PyThreadState* __tstate = wxPyBeginAllowThreads();
33333         result = ((wxHelpEvent const *)arg1)->GetPosition();
33334
33335         wxPyEndAllowThreads(__tstate);
33336         if (PyErr_Occurred()) SWIG_fail;
33337     }
33338     {
33339         wxPoint * resultptr;
33340         resultptr = new wxPoint((wxPoint const &)(result));
33341         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
33342     }
33343     return resultobj;
33344     fail:
33345     return NULL;
33346 }
33347
33348
33349 static PyObject *_wrap_HelpEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33350     PyObject *resultobj;
33351     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33352     wxPoint *arg2 = 0 ;
33353     wxPoint temp2 ;
33354     PyObject * obj0 = 0 ;
33355     PyObject * obj1 = 0 ;
33356     char *kwnames[] = {
33357         (char *) "self",(char *) "pos", NULL
33358     };
33359
33360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
33361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33362     if (SWIG_arg_fail(1)) SWIG_fail;
33363     {
33364         arg2 = &temp2;
33365         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33366     }
33367     {
33368         PyThreadState* __tstate = wxPyBeginAllowThreads();
33369         (arg1)->SetPosition((wxPoint const &)*arg2);
33370
33371         wxPyEndAllowThreads(__tstate);
33372         if (PyErr_Occurred()) SWIG_fail;
33373     }
33374     Py_INCREF(Py_None); resultobj = Py_None;
33375     return resultobj;
33376     fail:
33377     return NULL;
33378 }
33379
33380
33381 static PyObject *_wrap_HelpEvent_GetLink(PyObject *, PyObject *args, PyObject *kwargs) {
33382     PyObject *resultobj;
33383     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33384     wxString *result;
33385     PyObject * obj0 = 0 ;
33386     char *kwnames[] = {
33387         (char *) "self", NULL
33388     };
33389
33390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetLink",kwnames,&obj0)) goto fail;
33391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33392     if (SWIG_arg_fail(1)) SWIG_fail;
33393     {
33394         PyThreadState* __tstate = wxPyBeginAllowThreads();
33395         {
33396             wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetLink();
33397             result = (wxString *) &_result_ref;
33398         }
33399
33400         wxPyEndAllowThreads(__tstate);
33401         if (PyErr_Occurred()) SWIG_fail;
33402     }
33403     {
33404 #if wxUSE_UNICODE
33405         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
33406 #else
33407         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
33408 #endif
33409     }
33410     return resultobj;
33411     fail:
33412     return NULL;
33413 }
33414
33415
33416 static PyObject *_wrap_HelpEvent_SetLink(PyObject *, PyObject *args, PyObject *kwargs) {
33417     PyObject *resultobj;
33418     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33419     wxString *arg2 = 0 ;
33420     bool temp2 = false ;
33421     PyObject * obj0 = 0 ;
33422     PyObject * obj1 = 0 ;
33423     char *kwnames[] = {
33424         (char *) "self",(char *) "link", NULL
33425     };
33426
33427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetLink",kwnames,&obj0,&obj1)) goto fail;
33428     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33429     if (SWIG_arg_fail(1)) SWIG_fail;
33430     {
33431         arg2 = wxString_in_helper(obj1);
33432         if (arg2 == NULL) SWIG_fail;
33433         temp2 = true;
33434     }
33435     {
33436         PyThreadState* __tstate = wxPyBeginAllowThreads();
33437         (arg1)->SetLink((wxString const &)*arg2);
33438
33439         wxPyEndAllowThreads(__tstate);
33440         if (PyErr_Occurred()) SWIG_fail;
33441     }
33442     Py_INCREF(Py_None); resultobj = Py_None;
33443     {
33444         if (temp2)
33445         delete arg2;
33446     }
33447     return resultobj;
33448     fail:
33449     {
33450         if (temp2)
33451         delete arg2;
33452     }
33453     return NULL;
33454 }
33455
33456
33457 static PyObject *_wrap_HelpEvent_GetTarget(PyObject *, PyObject *args, PyObject *kwargs) {
33458     PyObject *resultobj;
33459     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33460     wxString *result;
33461     PyObject * obj0 = 0 ;
33462     char *kwnames[] = {
33463         (char *) "self", NULL
33464     };
33465
33466     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpEvent_GetTarget",kwnames,&obj0)) goto fail;
33467     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33468     if (SWIG_arg_fail(1)) SWIG_fail;
33469     {
33470         PyThreadState* __tstate = wxPyBeginAllowThreads();
33471         {
33472             wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetTarget();
33473             result = (wxString *) &_result_ref;
33474         }
33475
33476         wxPyEndAllowThreads(__tstate);
33477         if (PyErr_Occurred()) SWIG_fail;
33478     }
33479     {
33480 #if wxUSE_UNICODE
33481         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
33482 #else
33483         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
33484 #endif
33485     }
33486     return resultobj;
33487     fail:
33488     return NULL;
33489 }
33490
33491
33492 static PyObject *_wrap_HelpEvent_SetTarget(PyObject *, PyObject *args, PyObject *kwargs) {
33493     PyObject *resultobj;
33494     wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
33495     wxString *arg2 = 0 ;
33496     bool temp2 = false ;
33497     PyObject * obj0 = 0 ;
33498     PyObject * obj1 = 0 ;
33499     char *kwnames[] = {
33500         (char *) "self",(char *) "target", NULL
33501     };
33502
33503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetTarget",kwnames,&obj0,&obj1)) goto fail;
33504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_EXCEPTION | 0);
33505     if (SWIG_arg_fail(1)) SWIG_fail;
33506     {
33507         arg2 = wxString_in_helper(obj1);
33508         if (arg2 == NULL) SWIG_fail;
33509         temp2 = true;
33510     }
33511     {
33512         PyThreadState* __tstate = wxPyBeginAllowThreads();
33513         (arg1)->SetTarget((wxString const &)*arg2);
33514
33515         wxPyEndAllowThreads(__tstate);
33516         if (PyErr_Occurred()) SWIG_fail;
33517     }
33518     Py_INCREF(Py_None); resultobj = Py_None;
33519     {
33520         if (temp2)
33521         delete arg2;
33522     }
33523     return resultobj;
33524     fail:
33525     {
33526         if (temp2)
33527         delete arg2;
33528     }
33529     return NULL;
33530 }
33531
33532
33533 static PyObject * HelpEvent_swigregister(PyObject *, PyObject *args) {
33534     PyObject *obj;
33535     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33536     SWIG_TypeClientData(SWIGTYPE_p_wxHelpEvent, obj);
33537     Py_INCREF(obj);
33538     return Py_BuildValue((char *)"");
33539 }
33540 static PyObject *_wrap_new_ContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33541     PyObject *resultobj;
33542     wxWindow *arg1 = (wxWindow *) NULL ;
33543     bool arg2 = (bool) true ;
33544     wxContextHelp *result;
33545     PyObject * obj0 = 0 ;
33546     PyObject * obj1 = 0 ;
33547     char *kwnames[] = {
33548         (char *) "window",(char *) "doNow", NULL
33549     };
33550
33551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ContextHelp",kwnames,&obj0,&obj1)) goto fail;
33552     if (obj0) {
33553         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33554         if (SWIG_arg_fail(1)) SWIG_fail;
33555     }
33556     if (obj1) {
33557         {
33558             arg2 = (bool)(SWIG_As_bool(obj1));
33559             if (SWIG_arg_fail(2)) SWIG_fail;
33560         }
33561     }
33562     {
33563         if (!wxPyCheckForApp()) SWIG_fail;
33564         PyThreadState* __tstate = wxPyBeginAllowThreads();
33565         result = (wxContextHelp *)new wxContextHelp(arg1,arg2);
33566
33567         wxPyEndAllowThreads(__tstate);
33568         if (PyErr_Occurred()) SWIG_fail;
33569     }
33570     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextHelp, 1);
33571     return resultobj;
33572     fail:
33573     return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_delete_ContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33578     PyObject *resultobj;
33579     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33580     PyObject * obj0 = 0 ;
33581     char *kwnames[] = {
33582         (char *) "self", NULL
33583     };
33584
33585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ContextHelp",kwnames,&obj0)) goto fail;
33586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33587     if (SWIG_arg_fail(1)) SWIG_fail;
33588     {
33589         PyThreadState* __tstate = wxPyBeginAllowThreads();
33590         delete arg1;
33591
33592         wxPyEndAllowThreads(__tstate);
33593         if (PyErr_Occurred()) SWIG_fail;
33594     }
33595     Py_INCREF(Py_None); resultobj = Py_None;
33596     return resultobj;
33597     fail:
33598     return NULL;
33599 }
33600
33601
33602 static PyObject *_wrap_ContextHelp_BeginContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33603     PyObject *resultobj;
33604     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33605     wxWindow *arg2 = (wxWindow *) NULL ;
33606     bool result;
33607     PyObject * obj0 = 0 ;
33608     PyObject * obj1 = 0 ;
33609     char *kwnames[] = {
33610         (char *) "self",(char *) "window", NULL
33611     };
33612
33613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ContextHelp_BeginContextHelp",kwnames,&obj0,&obj1)) goto fail;
33614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33615     if (SWIG_arg_fail(1)) SWIG_fail;
33616     if (obj1) {
33617         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33618         if (SWIG_arg_fail(2)) SWIG_fail;
33619     }
33620     {
33621         PyThreadState* __tstate = wxPyBeginAllowThreads();
33622         result = (bool)(arg1)->BeginContextHelp(arg2);
33623
33624         wxPyEndAllowThreads(__tstate);
33625         if (PyErr_Occurred()) SWIG_fail;
33626     }
33627     {
33628         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33629     }
33630     return resultobj;
33631     fail:
33632     return NULL;
33633 }
33634
33635
33636 static PyObject *_wrap_ContextHelp_EndContextHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33637     PyObject *resultobj;
33638     wxContextHelp *arg1 = (wxContextHelp *) 0 ;
33639     bool result;
33640     PyObject * obj0 = 0 ;
33641     char *kwnames[] = {
33642         (char *) "self", NULL
33643     };
33644
33645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextHelp_EndContextHelp",kwnames,&obj0)) goto fail;
33646     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextHelp, SWIG_POINTER_EXCEPTION | 0);
33647     if (SWIG_arg_fail(1)) SWIG_fail;
33648     {
33649         PyThreadState* __tstate = wxPyBeginAllowThreads();
33650         result = (bool)(arg1)->EndContextHelp();
33651
33652         wxPyEndAllowThreads(__tstate);
33653         if (PyErr_Occurred()) SWIG_fail;
33654     }
33655     {
33656         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33657     }
33658     return resultobj;
33659     fail:
33660     return NULL;
33661 }
33662
33663
33664 static PyObject * ContextHelp_swigregister(PyObject *, PyObject *args) {
33665     PyObject *obj;
33666     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33667     SWIG_TypeClientData(SWIGTYPE_p_wxContextHelp, obj);
33668     Py_INCREF(obj);
33669     return Py_BuildValue((char *)"");
33670 }
33671 static PyObject *_wrap_new_ContextHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
33672     PyObject *resultobj;
33673     wxWindow *arg1 = (wxWindow *) 0 ;
33674     int arg2 = (int) wxID_CONTEXT_HELP ;
33675     wxPoint const &arg3_defvalue = wxDefaultPosition ;
33676     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33677     wxSize const &arg4_defvalue = wxDefaultSize ;
33678     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33679     long arg5 = (long) wxBU_AUTODRAW ;
33680     wxContextHelpButton *result;
33681     wxPoint temp3 ;
33682     wxSize temp4 ;
33683     PyObject * obj0 = 0 ;
33684     PyObject * obj1 = 0 ;
33685     PyObject * obj2 = 0 ;
33686     PyObject * obj3 = 0 ;
33687     PyObject * obj4 = 0 ;
33688     char *kwnames[] = {
33689         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
33690     };
33691
33692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_ContextHelpButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33694     if (SWIG_arg_fail(1)) SWIG_fail;
33695     if (obj1) {
33696         {
33697             arg2 = (int)(SWIG_As_int(obj1));
33698             if (SWIG_arg_fail(2)) SWIG_fail;
33699         }
33700     }
33701     if (obj2) {
33702         {
33703             arg3 = &temp3;
33704             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33705         }
33706     }
33707     if (obj3) {
33708         {
33709             arg4 = &temp4;
33710             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33711         }
33712     }
33713     if (obj4) {
33714         {
33715             arg5 = (long)(SWIG_As_long(obj4));
33716             if (SWIG_arg_fail(5)) SWIG_fail;
33717         }
33718     }
33719     {
33720         if (!wxPyCheckForApp()) SWIG_fail;
33721         PyThreadState* __tstate = wxPyBeginAllowThreads();
33722         result = (wxContextHelpButton *)new wxContextHelpButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
33723
33724         wxPyEndAllowThreads(__tstate);
33725         if (PyErr_Occurred()) SWIG_fail;
33726     }
33727     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextHelpButton, 1);
33728     return resultobj;
33729     fail:
33730     return NULL;
33731 }
33732
33733
33734 static PyObject * ContextHelpButton_swigregister(PyObject *, PyObject *args) {
33735     PyObject *obj;
33736     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33737     SWIG_TypeClientData(SWIGTYPE_p_wxContextHelpButton, obj);
33738     Py_INCREF(obj);
33739     return Py_BuildValue((char *)"");
33740 }
33741 static PyObject *_wrap_HelpProvider_Set(PyObject *, PyObject *args, PyObject *kwargs) {
33742     PyObject *resultobj;
33743     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33744     wxHelpProvider *result;
33745     PyObject * obj0 = 0 ;
33746     char *kwnames[] = {
33747         (char *) "helpProvider", NULL
33748     };
33749
33750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpProvider_Set",kwnames,&obj0)) goto fail;
33751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33752     if (SWIG_arg_fail(1)) SWIG_fail;
33753     {
33754         PyThreadState* __tstate = wxPyBeginAllowThreads();
33755         result = (wxHelpProvider *)wxHelpProvider::Set(arg1);
33756
33757         wxPyEndAllowThreads(__tstate);
33758         if (PyErr_Occurred()) SWIG_fail;
33759     }
33760     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpProvider, 0);
33761     return resultobj;
33762     fail:
33763     return NULL;
33764 }
33765
33766
33767 static PyObject *_wrap_HelpProvider_Get(PyObject *, PyObject *args, PyObject *kwargs) {
33768     PyObject *resultobj;
33769     wxHelpProvider *result;
33770     char *kwnames[] = {
33771         NULL
33772     };
33773
33774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":HelpProvider_Get",kwnames)) goto fail;
33775     {
33776         PyThreadState* __tstate = wxPyBeginAllowThreads();
33777         result = (wxHelpProvider *)wxHelpProvider::Get();
33778
33779         wxPyEndAllowThreads(__tstate);
33780         if (PyErr_Occurred()) SWIG_fail;
33781     }
33782     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxHelpProvider, 0);
33783     return resultobj;
33784     fail:
33785     return NULL;
33786 }
33787
33788
33789 static PyObject *_wrap_HelpProvider_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33790     PyObject *resultobj;
33791     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33792     wxWindow *arg2 = (wxWindow *) 0 ;
33793     wxString result;
33794     PyObject * obj0 = 0 ;
33795     PyObject * obj1 = 0 ;
33796     char *kwnames[] = {
33797         (char *) "self",(char *) "window", NULL
33798     };
33799
33800     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_GetHelp",kwnames,&obj0,&obj1)) goto fail;
33801     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33802     if (SWIG_arg_fail(1)) SWIG_fail;
33803     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33804     if (SWIG_arg_fail(2)) SWIG_fail;
33805     {
33806         PyThreadState* __tstate = wxPyBeginAllowThreads();
33807         result = (arg1)->GetHelp((wxWindow const *)arg2);
33808
33809         wxPyEndAllowThreads(__tstate);
33810         if (PyErr_Occurred()) SWIG_fail;
33811     }
33812     {
33813 #if wxUSE_UNICODE
33814         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33815 #else
33816         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33817 #endif
33818     }
33819     return resultobj;
33820     fail:
33821     return NULL;
33822 }
33823
33824
33825 static PyObject *_wrap_HelpProvider_ShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33826     PyObject *resultobj;
33827     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33828     wxWindow *arg2 = (wxWindow *) 0 ;
33829     bool result;
33830     PyObject * obj0 = 0 ;
33831     PyObject * obj1 = 0 ;
33832     char *kwnames[] = {
33833         (char *) "self",(char *) "window", NULL
33834     };
33835
33836     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_ShowHelp",kwnames,&obj0,&obj1)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
33843         result = (bool)(arg1)->ShowHelp(arg2);
33844
33845         wxPyEndAllowThreads(__tstate);
33846         if (PyErr_Occurred()) SWIG_fail;
33847     }
33848     {
33849         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33850     }
33851     return resultobj;
33852     fail:
33853     return NULL;
33854 }
33855
33856
33857 static PyObject *_wrap_HelpProvider_AddHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33858     PyObject *resultobj;
33859     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33860     wxWindow *arg2 = (wxWindow *) 0 ;
33861     wxString *arg3 = 0 ;
33862     bool temp3 = false ;
33863     PyObject * obj0 = 0 ;
33864     PyObject * obj1 = 0 ;
33865     PyObject * obj2 = 0 ;
33866     char *kwnames[] = {
33867         (char *) "self",(char *) "window",(char *) "text", NULL
33868     };
33869
33870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
33871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33872     if (SWIG_arg_fail(1)) SWIG_fail;
33873     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33874     if (SWIG_arg_fail(2)) SWIG_fail;
33875     {
33876         arg3 = wxString_in_helper(obj2);
33877         if (arg3 == NULL) SWIG_fail;
33878         temp3 = true;
33879     }
33880     {
33881         PyThreadState* __tstate = wxPyBeginAllowThreads();
33882         (arg1)->AddHelp(arg2,(wxString const &)*arg3);
33883
33884         wxPyEndAllowThreads(__tstate);
33885         if (PyErr_Occurred()) SWIG_fail;
33886     }
33887     Py_INCREF(Py_None); resultobj = Py_None;
33888     {
33889         if (temp3)
33890         delete arg3;
33891     }
33892     return resultobj;
33893     fail:
33894     {
33895         if (temp3)
33896         delete arg3;
33897     }
33898     return NULL;
33899 }
33900
33901
33902 static PyObject *_wrap_HelpProvider_AddHelpById(PyObject *, PyObject *args, PyObject *kwargs) {
33903     PyObject *resultobj;
33904     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33905     int arg2 ;
33906     wxString *arg3 = 0 ;
33907     bool temp3 = false ;
33908     PyObject * obj0 = 0 ;
33909     PyObject * obj1 = 0 ;
33910     PyObject * obj2 = 0 ;
33911     char *kwnames[] = {
33912         (char *) "self",(char *) "id",(char *) "text", NULL
33913     };
33914
33915     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelpById",kwnames,&obj0,&obj1,&obj2)) goto fail;
33916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33917     if (SWIG_arg_fail(1)) SWIG_fail;
33918     {
33919         arg2 = (int)(SWIG_As_int(obj1));
33920         if (SWIG_arg_fail(2)) SWIG_fail;
33921     }
33922     {
33923         arg3 = wxString_in_helper(obj2);
33924         if (arg3 == NULL) SWIG_fail;
33925         temp3 = true;
33926     }
33927     {
33928         PyThreadState* __tstate = wxPyBeginAllowThreads();
33929         (arg1)->AddHelp(arg2,(wxString const &)*arg3);
33930
33931         wxPyEndAllowThreads(__tstate);
33932         if (PyErr_Occurred()) SWIG_fail;
33933     }
33934     Py_INCREF(Py_None); resultobj = Py_None;
33935     {
33936         if (temp3)
33937         delete arg3;
33938     }
33939     return resultobj;
33940     fail:
33941     {
33942         if (temp3)
33943         delete arg3;
33944     }
33945     return NULL;
33946 }
33947
33948
33949 static PyObject *_wrap_HelpProvider_RemoveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
33950     PyObject *resultobj;
33951     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33952     wxWindow *arg2 = (wxWindow *) 0 ;
33953     PyObject * obj0 = 0 ;
33954     PyObject * obj1 = 0 ;
33955     char *kwnames[] = {
33956         (char *) "self",(char *) "window", NULL
33957     };
33958
33959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_RemoveHelp",kwnames,&obj0,&obj1)) goto fail;
33960     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33961     if (SWIG_arg_fail(1)) SWIG_fail;
33962     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33963     if (SWIG_arg_fail(2)) SWIG_fail;
33964     {
33965         PyThreadState* __tstate = wxPyBeginAllowThreads();
33966         (arg1)->RemoveHelp(arg2);
33967
33968         wxPyEndAllowThreads(__tstate);
33969         if (PyErr_Occurred()) SWIG_fail;
33970     }
33971     Py_INCREF(Py_None); resultobj = Py_None;
33972     return resultobj;
33973     fail:
33974     return NULL;
33975 }
33976
33977
33978 static PyObject *_wrap_HelpProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33979     PyObject *resultobj;
33980     wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
33981     PyObject * obj0 = 0 ;
33982     char *kwnames[] = {
33983         (char *) "self", NULL
33984     };
33985
33986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpProvider_Destroy",kwnames,&obj0)) goto fail;
33987     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_EXCEPTION | 0);
33988     if (SWIG_arg_fail(1)) SWIG_fail;
33989     {
33990         PyThreadState* __tstate = wxPyBeginAllowThreads();
33991         wxHelpProvider_Destroy(arg1);
33992
33993         wxPyEndAllowThreads(__tstate);
33994         if (PyErr_Occurred()) SWIG_fail;
33995     }
33996     Py_INCREF(Py_None); resultobj = Py_None;
33997     return resultobj;
33998     fail:
33999     return NULL;
34000 }
34001
34002
34003 static PyObject * HelpProvider_swigregister(PyObject *, PyObject *args) {
34004     PyObject *obj;
34005     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34006     SWIG_TypeClientData(SWIGTYPE_p_wxHelpProvider, obj);
34007     Py_INCREF(obj);
34008     return Py_BuildValue((char *)"");
34009 }
34010 static PyObject *_wrap_new_SimpleHelpProvider(PyObject *, PyObject *args, PyObject *kwargs) {
34011     PyObject *resultobj;
34012     wxSimpleHelpProvider *result;
34013     char *kwnames[] = {
34014         NULL
34015     };
34016
34017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SimpleHelpProvider",kwnames)) goto fail;
34018     {
34019         PyThreadState* __tstate = wxPyBeginAllowThreads();
34020         result = (wxSimpleHelpProvider *)new wxSimpleHelpProvider();
34021
34022         wxPyEndAllowThreads(__tstate);
34023         if (PyErr_Occurred()) SWIG_fail;
34024     }
34025     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSimpleHelpProvider, 1);
34026     return resultobj;
34027     fail:
34028     return NULL;
34029 }
34030
34031
34032 static PyObject * SimpleHelpProvider_swigregister(PyObject *, PyObject *args) {
34033     PyObject *obj;
34034     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34035     SWIG_TypeClientData(SWIGTYPE_p_wxSimpleHelpProvider, obj);
34036     Py_INCREF(obj);
34037     return Py_BuildValue((char *)"");
34038 }
34039 static PyObject *_wrap_new_DragImage(PyObject *, PyObject *args, PyObject *kwargs) {
34040     PyObject *resultobj;
34041     wxBitmap *arg1 = 0 ;
34042     wxCursor const &arg2_defvalue = wxNullCursor ;
34043     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34044     wxGenericDragImage *result;
34045     PyObject * obj0 = 0 ;
34046     PyObject * obj1 = 0 ;
34047     char *kwnames[] = {
34048         (char *) "image",(char *) "cursor", NULL
34049     };
34050
34051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragImage",kwnames,&obj0,&obj1)) goto fail;
34052     {
34053         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
34054         if (SWIG_arg_fail(1)) SWIG_fail;
34055         if (arg1 == NULL) {
34056             SWIG_null_ref("wxBitmap");
34057         }
34058         if (SWIG_arg_fail(1)) SWIG_fail;
34059     }
34060     if (obj1) {
34061         {
34062             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34063             if (SWIG_arg_fail(2)) SWIG_fail;
34064             if (arg2 == NULL) {
34065                 SWIG_null_ref("wxCursor");
34066             }
34067             if (SWIG_arg_fail(2)) SWIG_fail;
34068         }
34069     }
34070     {
34071         if (!wxPyCheckForApp()) SWIG_fail;
34072         PyThreadState* __tstate = wxPyBeginAllowThreads();
34073         result = (wxGenericDragImage *)new wxGenericDragImage((wxBitmap const &)*arg1,(wxCursor const &)*arg2);
34074
34075         wxPyEndAllowThreads(__tstate);
34076         if (PyErr_Occurred()) SWIG_fail;
34077     }
34078     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34079     return resultobj;
34080     fail:
34081     return NULL;
34082 }
34083
34084
34085 static PyObject *_wrap_new_DragIcon(PyObject *, PyObject *args, PyObject *kwargs) {
34086     PyObject *resultobj;
34087     wxIcon *arg1 = 0 ;
34088     wxCursor const &arg2_defvalue = wxNullCursor ;
34089     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34090     wxGenericDragImage *result;
34091     PyObject * obj0 = 0 ;
34092     PyObject * obj1 = 0 ;
34093     char *kwnames[] = {
34094         (char *) "image",(char *) "cursor", NULL
34095     };
34096
34097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragIcon",kwnames,&obj0,&obj1)) goto fail;
34098     {
34099         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
34100         if (SWIG_arg_fail(1)) SWIG_fail;
34101         if (arg1 == NULL) {
34102             SWIG_null_ref("wxIcon");
34103         }
34104         if (SWIG_arg_fail(1)) SWIG_fail;
34105     }
34106     if (obj1) {
34107         {
34108             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34109             if (SWIG_arg_fail(2)) SWIG_fail;
34110             if (arg2 == NULL) {
34111                 SWIG_null_ref("wxCursor");
34112             }
34113             if (SWIG_arg_fail(2)) SWIG_fail;
34114         }
34115     }
34116     {
34117         if (!wxPyCheckForApp()) SWIG_fail;
34118         PyThreadState* __tstate = wxPyBeginAllowThreads();
34119         result = (wxGenericDragImage *)new wxGenericDragImage((wxIcon const &)*arg1,(wxCursor const &)*arg2);
34120
34121         wxPyEndAllowThreads(__tstate);
34122         if (PyErr_Occurred()) SWIG_fail;
34123     }
34124     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34125     return resultobj;
34126     fail:
34127     return NULL;
34128 }
34129
34130
34131 static PyObject *_wrap_new_DragString(PyObject *, PyObject *args, PyObject *kwargs) {
34132     PyObject *resultobj;
34133     wxString *arg1 = 0 ;
34134     wxCursor const &arg2_defvalue = wxNullCursor ;
34135     wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
34136     wxGenericDragImage *result;
34137     bool temp1 = false ;
34138     PyObject * obj0 = 0 ;
34139     PyObject * obj1 = 0 ;
34140     char *kwnames[] = {
34141         (char *) "str",(char *) "cursor", NULL
34142     };
34143
34144     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragString",kwnames,&obj0,&obj1)) goto fail;
34145     {
34146         arg1 = wxString_in_helper(obj0);
34147         if (arg1 == NULL) SWIG_fail;
34148         temp1 = true;
34149     }
34150     if (obj1) {
34151         {
34152             SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
34153             if (SWIG_arg_fail(2)) SWIG_fail;
34154             if (arg2 == NULL) {
34155                 SWIG_null_ref("wxCursor");
34156             }
34157             if (SWIG_arg_fail(2)) SWIG_fail;
34158         }
34159     }
34160     {
34161         if (!wxPyCheckForApp()) SWIG_fail;
34162         PyThreadState* __tstate = wxPyBeginAllowThreads();
34163         result = (wxGenericDragImage *)new wxGenericDragImage((wxString const &)*arg1,(wxCursor const &)*arg2);
34164
34165         wxPyEndAllowThreads(__tstate);
34166         if (PyErr_Occurred()) SWIG_fail;
34167     }
34168     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34169     {
34170         if (temp1)
34171         delete arg1;
34172     }
34173     return resultobj;
34174     fail:
34175     {
34176         if (temp1)
34177         delete arg1;
34178     }
34179     return NULL;
34180 }
34181
34182
34183 static PyObject *_wrap_new_DragTreeItem(PyObject *, PyObject *args, PyObject *kwargs) {
34184     PyObject *resultobj;
34185     wxPyTreeCtrl *arg1 = 0 ;
34186     wxTreeItemId *arg2 = 0 ;
34187     wxGenericDragImage *result;
34188     PyObject * obj0 = 0 ;
34189     PyObject * obj1 = 0 ;
34190     char *kwnames[] = {
34191         (char *) "treeCtrl",(char *) "id", NULL
34192     };
34193
34194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragTreeItem",kwnames,&obj0,&obj1)) goto fail;
34195     {
34196         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_EXCEPTION | 0);
34197         if (SWIG_arg_fail(1)) SWIG_fail;
34198         if (arg1 == NULL) {
34199             SWIG_null_ref("wxPyTreeCtrl");
34200         }
34201         if (SWIG_arg_fail(1)) SWIG_fail;
34202     }
34203     {
34204         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_EXCEPTION | 0);
34205         if (SWIG_arg_fail(2)) SWIG_fail;
34206         if (arg2 == NULL) {
34207             SWIG_null_ref("wxTreeItemId");
34208         }
34209         if (SWIG_arg_fail(2)) SWIG_fail;
34210     }
34211     {
34212         if (!wxPyCheckForApp()) SWIG_fail;
34213         PyThreadState* __tstate = wxPyBeginAllowThreads();
34214         result = (wxGenericDragImage *)new wxGenericDragImage((wxPyTreeCtrl const &)*arg1,*arg2);
34215
34216         wxPyEndAllowThreads(__tstate);
34217         if (PyErr_Occurred()) SWIG_fail;
34218     }
34219     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34220     return resultobj;
34221     fail:
34222     return NULL;
34223 }
34224
34225
34226 static PyObject *_wrap_new_DragListItem(PyObject *, PyObject *args, PyObject *kwargs) {
34227     PyObject *resultobj;
34228     wxPyListCtrl *arg1 = 0 ;
34229     long arg2 ;
34230     wxGenericDragImage *result;
34231     PyObject * obj0 = 0 ;
34232     PyObject * obj1 = 0 ;
34233     char *kwnames[] = {
34234         (char *) "listCtrl",(char *) "id", NULL
34235     };
34236
34237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragListItem",kwnames,&obj0,&obj1)) goto fail;
34238     {
34239         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_EXCEPTION | 0);
34240         if (SWIG_arg_fail(1)) SWIG_fail;
34241         if (arg1 == NULL) {
34242             SWIG_null_ref("wxPyListCtrl");
34243         }
34244         if (SWIG_arg_fail(1)) SWIG_fail;
34245     }
34246     {
34247         arg2 = (long)(SWIG_As_long(obj1));
34248         if (SWIG_arg_fail(2)) SWIG_fail;
34249     }
34250     {
34251         if (!wxPyCheckForApp()) SWIG_fail;
34252         PyThreadState* __tstate = wxPyBeginAllowThreads();
34253         result = (wxGenericDragImage *)new wxGenericDragImage((wxPyListCtrl const &)*arg1,arg2);
34254
34255         wxPyEndAllowThreads(__tstate);
34256         if (PyErr_Occurred()) SWIG_fail;
34257     }
34258     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGenericDragImage, 1);
34259     return resultobj;
34260     fail:
34261     return NULL;
34262 }
34263
34264
34265 static PyObject *_wrap_delete_DragImage(PyObject *, PyObject *args, PyObject *kwargs) {
34266     PyObject *resultobj;
34267     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34268     PyObject * obj0 = 0 ;
34269     char *kwnames[] = {
34270         (char *) "self", NULL
34271     };
34272
34273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DragImage",kwnames,&obj0)) goto fail;
34274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34275     if (SWIG_arg_fail(1)) SWIG_fail;
34276     {
34277         PyThreadState* __tstate = wxPyBeginAllowThreads();
34278         delete arg1;
34279
34280         wxPyEndAllowThreads(__tstate);
34281         if (PyErr_Occurred()) SWIG_fail;
34282     }
34283     Py_INCREF(Py_None); resultobj = Py_None;
34284     return resultobj;
34285     fail:
34286     return NULL;
34287 }
34288
34289
34290 static PyObject *_wrap_DragImage_SetBackingBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
34291     PyObject *resultobj;
34292     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34293     wxBitmap *arg2 = (wxBitmap *) 0 ;
34294     PyObject * obj0 = 0 ;
34295     PyObject * obj1 = 0 ;
34296     char *kwnames[] = {
34297         (char *) "self",(char *) "bitmap", NULL
34298     };
34299
34300     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_SetBackingBitmap",kwnames,&obj0,&obj1)) goto fail;
34301     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34302     if (SWIG_arg_fail(1)) SWIG_fail;
34303     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
34304     if (SWIG_arg_fail(2)) SWIG_fail;
34305     {
34306         PyThreadState* __tstate = wxPyBeginAllowThreads();
34307         (arg1)->SetBackingBitmap(arg2);
34308
34309         wxPyEndAllowThreads(__tstate);
34310         if (PyErr_Occurred()) SWIG_fail;
34311     }
34312     Py_INCREF(Py_None); resultobj = Py_None;
34313     return resultobj;
34314     fail:
34315     return NULL;
34316 }
34317
34318
34319 static PyObject *_wrap_DragImage_BeginDrag(PyObject *, PyObject *args, PyObject *kwargs) {
34320     PyObject *resultobj;
34321     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34322     wxPoint *arg2 = 0 ;
34323     wxWindow *arg3 = (wxWindow *) 0 ;
34324     bool arg4 = (bool) false ;
34325     wxRect *arg5 = (wxRect *) NULL ;
34326     bool result;
34327     wxPoint temp2 ;
34328     PyObject * obj0 = 0 ;
34329     PyObject * obj1 = 0 ;
34330     PyObject * obj2 = 0 ;
34331     PyObject * obj3 = 0 ;
34332     PyObject * obj4 = 0 ;
34333     char *kwnames[] = {
34334         (char *) "self",(char *) "hotspot",(char *) "window",(char *) "fullScreen",(char *) "rect", NULL
34335     };
34336
34337     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DragImage_BeginDrag",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34338     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34339     if (SWIG_arg_fail(1)) SWIG_fail;
34340     {
34341         arg2 = &temp2;
34342         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34343     }
34344     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34345     if (SWIG_arg_fail(3)) SWIG_fail;
34346     if (obj3) {
34347         {
34348             arg4 = (bool)(SWIG_As_bool(obj3));
34349             if (SWIG_arg_fail(4)) SWIG_fail;
34350         }
34351     }
34352     if (obj4) {
34353         SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
34354         if (SWIG_arg_fail(5)) SWIG_fail;
34355     }
34356     {
34357         PyThreadState* __tstate = wxPyBeginAllowThreads();
34358         result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4,arg5);
34359
34360         wxPyEndAllowThreads(__tstate);
34361         if (PyErr_Occurred()) SWIG_fail;
34362     }
34363     {
34364         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34365     }
34366     return resultobj;
34367     fail:
34368     return NULL;
34369 }
34370
34371
34372 static PyObject *_wrap_DragImage_BeginDragBounded(PyObject *, PyObject *args, PyObject *kwargs) {
34373     PyObject *resultobj;
34374     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34375     wxPoint *arg2 = 0 ;
34376     wxWindow *arg3 = (wxWindow *) 0 ;
34377     wxWindow *arg4 = (wxWindow *) 0 ;
34378     bool result;
34379     wxPoint temp2 ;
34380     PyObject * obj0 = 0 ;
34381     PyObject * obj1 = 0 ;
34382     PyObject * obj2 = 0 ;
34383     PyObject * obj3 = 0 ;
34384     char *kwnames[] = {
34385         (char *) "self",(char *) "hotspot",(char *) "window",(char *) "boundingWindow", NULL
34386     };
34387
34388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DragImage_BeginDragBounded",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34390     if (SWIG_arg_fail(1)) SWIG_fail;
34391     {
34392         arg2 = &temp2;
34393         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34394     }
34395     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34396     if (SWIG_arg_fail(3)) SWIG_fail;
34397     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34398     if (SWIG_arg_fail(4)) SWIG_fail;
34399     {
34400         PyThreadState* __tstate = wxPyBeginAllowThreads();
34401         result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4);
34402
34403         wxPyEndAllowThreads(__tstate);
34404         if (PyErr_Occurred()) SWIG_fail;
34405     }
34406     {
34407         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34408     }
34409     return resultobj;
34410     fail:
34411     return NULL;
34412 }
34413
34414
34415 static PyObject *_wrap_DragImage_EndDrag(PyObject *, PyObject *args, PyObject *kwargs) {
34416     PyObject *resultobj;
34417     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34418     bool result;
34419     PyObject * obj0 = 0 ;
34420     char *kwnames[] = {
34421         (char *) "self", NULL
34422     };
34423
34424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_EndDrag",kwnames,&obj0)) goto fail;
34425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34426     if (SWIG_arg_fail(1)) SWIG_fail;
34427     {
34428         PyThreadState* __tstate = wxPyBeginAllowThreads();
34429         result = (bool)(arg1)->EndDrag();
34430
34431         wxPyEndAllowThreads(__tstate);
34432         if (PyErr_Occurred()) SWIG_fail;
34433     }
34434     {
34435         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34436     }
34437     return resultobj;
34438     fail:
34439     return NULL;
34440 }
34441
34442
34443 static PyObject *_wrap_DragImage_Move(PyObject *, PyObject *args, PyObject *kwargs) {
34444     PyObject *resultobj;
34445     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34446     wxPoint *arg2 = 0 ;
34447     bool result;
34448     wxPoint temp2 ;
34449     PyObject * obj0 = 0 ;
34450     PyObject * obj1 = 0 ;
34451     char *kwnames[] = {
34452         (char *) "self",(char *) "pt", NULL
34453     };
34454
34455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_Move",kwnames,&obj0,&obj1)) goto fail;
34456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34457     if (SWIG_arg_fail(1)) SWIG_fail;
34458     {
34459         arg2 = &temp2;
34460         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34461     }
34462     {
34463         PyThreadState* __tstate = wxPyBeginAllowThreads();
34464         result = (bool)(arg1)->Move((wxPoint const &)*arg2);
34465
34466         wxPyEndAllowThreads(__tstate);
34467         if (PyErr_Occurred()) SWIG_fail;
34468     }
34469     {
34470         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34471     }
34472     return resultobj;
34473     fail:
34474     return NULL;
34475 }
34476
34477
34478 static PyObject *_wrap_DragImage_Show(PyObject *, PyObject *args, PyObject *kwargs) {
34479     PyObject *resultobj;
34480     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34481     bool result;
34482     PyObject * obj0 = 0 ;
34483     char *kwnames[] = {
34484         (char *) "self", NULL
34485     };
34486
34487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_Show",kwnames,&obj0)) goto fail;
34488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34489     if (SWIG_arg_fail(1)) SWIG_fail;
34490     {
34491         PyThreadState* __tstate = wxPyBeginAllowThreads();
34492         result = (bool)(arg1)->Show();
34493
34494         wxPyEndAllowThreads(__tstate);
34495         if (PyErr_Occurred()) SWIG_fail;
34496     }
34497     {
34498         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34499     }
34500     return resultobj;
34501     fail:
34502     return NULL;
34503 }
34504
34505
34506 static PyObject *_wrap_DragImage_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
34507     PyObject *resultobj;
34508     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34509     bool result;
34510     PyObject * obj0 = 0 ;
34511     char *kwnames[] = {
34512         (char *) "self", NULL
34513     };
34514
34515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DragImage_Hide",kwnames,&obj0)) goto fail;
34516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34517     if (SWIG_arg_fail(1)) SWIG_fail;
34518     {
34519         PyThreadState* __tstate = wxPyBeginAllowThreads();
34520         result = (bool)(arg1)->Hide();
34521
34522         wxPyEndAllowThreads(__tstate);
34523         if (PyErr_Occurred()) SWIG_fail;
34524     }
34525     {
34526         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34527     }
34528     return resultobj;
34529     fail:
34530     return NULL;
34531 }
34532
34533
34534 static PyObject *_wrap_DragImage_GetImageRect(PyObject *, PyObject *args, PyObject *kwargs) {
34535     PyObject *resultobj;
34536     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34537     wxPoint *arg2 = 0 ;
34538     wxRect result;
34539     wxPoint temp2 ;
34540     PyObject * obj0 = 0 ;
34541     PyObject * obj1 = 0 ;
34542     char *kwnames[] = {
34543         (char *) "self",(char *) "pos", NULL
34544     };
34545
34546     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_GetImageRect",kwnames,&obj0,&obj1)) goto fail;
34547     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34548     if (SWIG_arg_fail(1)) SWIG_fail;
34549     {
34550         arg2 = &temp2;
34551         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34552     }
34553     {
34554         PyThreadState* __tstate = wxPyBeginAllowThreads();
34555         result = ((wxGenericDragImage const *)arg1)->GetImageRect((wxPoint const &)*arg2);
34556
34557         wxPyEndAllowThreads(__tstate);
34558         if (PyErr_Occurred()) SWIG_fail;
34559     }
34560     {
34561         wxRect * resultptr;
34562         resultptr = new wxRect((wxRect &)(result));
34563         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
34564     }
34565     return resultobj;
34566     fail:
34567     return NULL;
34568 }
34569
34570
34571 static PyObject *_wrap_DragImage_DoDrawImage(PyObject *, PyObject *args, PyObject *kwargs) {
34572     PyObject *resultobj;
34573     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34574     wxDC *arg2 = 0 ;
34575     wxPoint *arg3 = 0 ;
34576     bool result;
34577     wxPoint temp3 ;
34578     PyObject * obj0 = 0 ;
34579     PyObject * obj1 = 0 ;
34580     PyObject * obj2 = 0 ;
34581     char *kwnames[] = {
34582         (char *) "self",(char *) "dc",(char *) "pos", NULL
34583     };
34584
34585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DragImage_DoDrawImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
34586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34587     if (SWIG_arg_fail(1)) SWIG_fail;
34588     {
34589         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
34590         if (SWIG_arg_fail(2)) SWIG_fail;
34591         if (arg2 == NULL) {
34592             SWIG_null_ref("wxDC");
34593         }
34594         if (SWIG_arg_fail(2)) SWIG_fail;
34595     }
34596     {
34597         arg3 = &temp3;
34598         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
34599     }
34600     {
34601         PyThreadState* __tstate = wxPyBeginAllowThreads();
34602         result = (bool)((wxGenericDragImage const *)arg1)->DoDrawImage(*arg2,(wxPoint const &)*arg3);
34603
34604         wxPyEndAllowThreads(__tstate);
34605         if (PyErr_Occurred()) SWIG_fail;
34606     }
34607     {
34608         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34609     }
34610     return resultobj;
34611     fail:
34612     return NULL;
34613 }
34614
34615
34616 static PyObject *_wrap_DragImage_UpdateBackingFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34617     PyObject *resultobj;
34618     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34619     wxDC *arg2 = 0 ;
34620     wxMemoryDC *arg3 = 0 ;
34621     wxRect *arg4 = 0 ;
34622     wxRect *arg5 = 0 ;
34623     bool result;
34624     wxRect temp4 ;
34625     wxRect temp5 ;
34626     PyObject * obj0 = 0 ;
34627     PyObject * obj1 = 0 ;
34628     PyObject * obj2 = 0 ;
34629     PyObject * obj3 = 0 ;
34630     PyObject * obj4 = 0 ;
34631     char *kwnames[] = {
34632         (char *) "self",(char *) "windowDC",(char *) "destDC",(char *) "sourceRect",(char *) "destRect", NULL
34633     };
34634
34635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_UpdateBackingFromWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34637     if (SWIG_arg_fail(1)) SWIG_fail;
34638     {
34639         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
34640         if (SWIG_arg_fail(2)) SWIG_fail;
34641         if (arg2 == NULL) {
34642             SWIG_null_ref("wxDC");
34643         }
34644         if (SWIG_arg_fail(2)) SWIG_fail;
34645     }
34646     {
34647         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
34648         if (SWIG_arg_fail(3)) SWIG_fail;
34649         if (arg3 == NULL) {
34650             SWIG_null_ref("wxMemoryDC");
34651         }
34652         if (SWIG_arg_fail(3)) SWIG_fail;
34653     }
34654     {
34655         arg4 = &temp4;
34656         if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
34657     }
34658     {
34659         arg5 = &temp5;
34660         if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
34661     }
34662     {
34663         PyThreadState* __tstate = wxPyBeginAllowThreads();
34664         result = (bool)((wxGenericDragImage const *)arg1)->UpdateBackingFromWindow(*arg2,*arg3,(wxRect const &)*arg4,(wxRect const &)*arg5);
34665
34666         wxPyEndAllowThreads(__tstate);
34667         if (PyErr_Occurred()) SWIG_fail;
34668     }
34669     {
34670         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34671     }
34672     return resultobj;
34673     fail:
34674     return NULL;
34675 }
34676
34677
34678 static PyObject *_wrap_DragImage_RedrawImage(PyObject *, PyObject *args, PyObject *kwargs) {
34679     PyObject *resultobj;
34680     wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
34681     wxPoint *arg2 = 0 ;
34682     wxPoint *arg3 = 0 ;
34683     bool arg4 ;
34684     bool arg5 ;
34685     bool result;
34686     wxPoint temp2 ;
34687     wxPoint temp3 ;
34688     PyObject * obj0 = 0 ;
34689     PyObject * obj1 = 0 ;
34690     PyObject * obj2 = 0 ;
34691     PyObject * obj3 = 0 ;
34692     PyObject * obj4 = 0 ;
34693     char *kwnames[] = {
34694         (char *) "self",(char *) "oldPos",(char *) "newPos",(char *) "eraseOld",(char *) "drawNew", NULL
34695     };
34696
34697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_RedrawImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_EXCEPTION | 0);
34699     if (SWIG_arg_fail(1)) SWIG_fail;
34700     {
34701         arg2 = &temp2;
34702         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34703     }
34704     {
34705         arg3 = &temp3;
34706         if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
34707     }
34708     {
34709         arg4 = (bool)(SWIG_As_bool(obj3));
34710         if (SWIG_arg_fail(4)) SWIG_fail;
34711     }
34712     {
34713         arg5 = (bool)(SWIG_As_bool(obj4));
34714         if (SWIG_arg_fail(5)) SWIG_fail;
34715     }
34716     {
34717         PyThreadState* __tstate = wxPyBeginAllowThreads();
34718         result = (bool)(arg1)->RedrawImage((wxPoint const &)*arg2,(wxPoint const &)*arg3,arg4,arg5);
34719
34720         wxPyEndAllowThreads(__tstate);
34721         if (PyErr_Occurred()) SWIG_fail;
34722     }
34723     {
34724         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34725     }
34726     return resultobj;
34727     fail:
34728     return NULL;
34729 }
34730
34731
34732 static PyObject * DragImage_swigregister(PyObject *, PyObject *args) {
34733     PyObject *obj;
34734     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34735     SWIG_TypeClientData(SWIGTYPE_p_wxGenericDragImage, obj);
34736     Py_INCREF(obj);
34737     return Py_BuildValue((char *)"");
34738 }
34739 static PyMethodDef SwigMethods[] = {
34740          { (char *)"new_Button", (PyCFunction) _wrap_new_Button, METH_VARARGS | METH_KEYWORDS, NULL},
34741          { (char *)"new_PreButton", (PyCFunction) _wrap_new_PreButton, METH_VARARGS | METH_KEYWORDS, NULL},
34742          { (char *)"Button_Create", (PyCFunction) _wrap_Button_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34743          { (char *)"Button_SetDefault", (PyCFunction) _wrap_Button_SetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
34744          { (char *)"Button_GetDefaultSize", (PyCFunction) _wrap_Button_GetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
34745          { (char *)"Button_GetClassDefaultAttributes", (PyCFunction) _wrap_Button_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34746          { (char *)"Button_swigregister", Button_swigregister, METH_VARARGS, NULL},
34747          { (char *)"new_BitmapButton", (PyCFunction) _wrap_new_BitmapButton, METH_VARARGS | METH_KEYWORDS, NULL},
34748          { (char *)"new_PreBitmapButton", (PyCFunction) _wrap_new_PreBitmapButton, METH_VARARGS | METH_KEYWORDS, NULL},
34749          { (char *)"BitmapButton_Create", (PyCFunction) _wrap_BitmapButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34750          { (char *)"BitmapButton_GetBitmapLabel", (PyCFunction) _wrap_BitmapButton_GetBitmapLabel, METH_VARARGS | METH_KEYWORDS, NULL},
34751          { (char *)"BitmapButton_GetBitmapDisabled", (PyCFunction) _wrap_BitmapButton_GetBitmapDisabled, METH_VARARGS | METH_KEYWORDS, NULL},
34752          { (char *)"BitmapButton_GetBitmapFocus", (PyCFunction) _wrap_BitmapButton_GetBitmapFocus, METH_VARARGS | METH_KEYWORDS, NULL},
34753          { (char *)"BitmapButton_GetBitmapSelected", (PyCFunction) _wrap_BitmapButton_GetBitmapSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34754          { (char *)"BitmapButton_SetBitmapDisabled", (PyCFunction) _wrap_BitmapButton_SetBitmapDisabled, METH_VARARGS | METH_KEYWORDS, NULL},
34755          { (char *)"BitmapButton_SetBitmapFocus", (PyCFunction) _wrap_BitmapButton_SetBitmapFocus, METH_VARARGS | METH_KEYWORDS, NULL},
34756          { (char *)"BitmapButton_SetBitmapSelected", (PyCFunction) _wrap_BitmapButton_SetBitmapSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34757          { (char *)"BitmapButton_SetBitmapLabel", (PyCFunction) _wrap_BitmapButton_SetBitmapLabel, METH_VARARGS | METH_KEYWORDS, NULL},
34758          { (char *)"BitmapButton_SetMargins", (PyCFunction) _wrap_BitmapButton_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
34759          { (char *)"BitmapButton_GetMarginX", (PyCFunction) _wrap_BitmapButton_GetMarginX, METH_VARARGS | METH_KEYWORDS, NULL},
34760          { (char *)"BitmapButton_GetMarginY", (PyCFunction) _wrap_BitmapButton_GetMarginY, METH_VARARGS | METH_KEYWORDS, NULL},
34761          { (char *)"BitmapButton_swigregister", BitmapButton_swigregister, METH_VARARGS, NULL},
34762          { (char *)"new_CheckBox", (PyCFunction) _wrap_new_CheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
34763          { (char *)"new_PreCheckBox", (PyCFunction) _wrap_new_PreCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
34764          { (char *)"CheckBox_Create", (PyCFunction) _wrap_CheckBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34765          { (char *)"CheckBox_GetValue", (PyCFunction) _wrap_CheckBox_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34766          { (char *)"CheckBox_IsChecked", (PyCFunction) _wrap_CheckBox_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
34767          { (char *)"CheckBox_SetValue", (PyCFunction) _wrap_CheckBox_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34768          { (char *)"CheckBox_Get3StateValue", (PyCFunction) _wrap_CheckBox_Get3StateValue, METH_VARARGS | METH_KEYWORDS, NULL},
34769          { (char *)"CheckBox_Set3StateValue", (PyCFunction) _wrap_CheckBox_Set3StateValue, METH_VARARGS | METH_KEYWORDS, NULL},
34770          { (char *)"CheckBox_Is3State", (PyCFunction) _wrap_CheckBox_Is3State, METH_VARARGS | METH_KEYWORDS, NULL},
34771          { (char *)"CheckBox_Is3rdStateAllowedForUser", (PyCFunction) _wrap_CheckBox_Is3rdStateAllowedForUser, METH_VARARGS | METH_KEYWORDS, NULL},
34772          { (char *)"CheckBox_GetClassDefaultAttributes", (PyCFunction) _wrap_CheckBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34773          { (char *)"CheckBox_swigregister", CheckBox_swigregister, METH_VARARGS, NULL},
34774          { (char *)"new_Choice", (PyCFunction) _wrap_new_Choice, METH_VARARGS | METH_KEYWORDS, NULL},
34775          { (char *)"new_PreChoice", (PyCFunction) _wrap_new_PreChoice, METH_VARARGS | METH_KEYWORDS, NULL},
34776          { (char *)"Choice_Create", (PyCFunction) _wrap_Choice_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34777          { (char *)"Choice_SetSelection", (PyCFunction) _wrap_Choice_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34778          { (char *)"Choice_SetStringSelection", (PyCFunction) _wrap_Choice_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34779          { (char *)"Choice_SetString", (PyCFunction) _wrap_Choice_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
34780          { (char *)"Choice_GetClassDefaultAttributes", (PyCFunction) _wrap_Choice_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34781          { (char *)"Choice_swigregister", Choice_swigregister, METH_VARARGS, NULL},
34782          { (char *)"new_ComboBox", (PyCFunction) _wrap_new_ComboBox, METH_VARARGS | METH_KEYWORDS, NULL},
34783          { (char *)"new_PreComboBox", (PyCFunction) _wrap_new_PreComboBox, METH_VARARGS | METH_KEYWORDS, NULL},
34784          { (char *)"ComboBox_Create", (PyCFunction) _wrap_ComboBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34785          { (char *)"ComboBox_GetValue", (PyCFunction) _wrap_ComboBox_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34786          { (char *)"ComboBox_SetValue", (PyCFunction) _wrap_ComboBox_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34787          { (char *)"ComboBox_Copy", (PyCFunction) _wrap_ComboBox_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
34788          { (char *)"ComboBox_Cut", (PyCFunction) _wrap_ComboBox_Cut, METH_VARARGS | METH_KEYWORDS, NULL},
34789          { (char *)"ComboBox_Paste", (PyCFunction) _wrap_ComboBox_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
34790          { (char *)"ComboBox_SetInsertionPoint", (PyCFunction) _wrap_ComboBox_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34791          { (char *)"ComboBox_GetInsertionPoint", (PyCFunction) _wrap_ComboBox_GetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34792          { (char *)"ComboBox_GetLastPosition", (PyCFunction) _wrap_ComboBox_GetLastPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34793          { (char *)"ComboBox_Replace", (PyCFunction) _wrap_ComboBox_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
34794          { (char *)"ComboBox_SetSelection", (PyCFunction) _wrap_ComboBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34795          { (char *)"ComboBox_SetMark", (PyCFunction) _wrap_ComboBox_SetMark, METH_VARARGS | METH_KEYWORDS, NULL},
34796          { (char *)"ComboBox_GetMark", (PyCFunction) _wrap_ComboBox_GetMark, METH_VARARGS | METH_KEYWORDS, NULL},
34797          { (char *)"ComboBox_SetStringSelection", (PyCFunction) _wrap_ComboBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34798          { (char *)"ComboBox_SetString", (PyCFunction) _wrap_ComboBox_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
34799          { (char *)"ComboBox_SetEditable", (PyCFunction) _wrap_ComboBox_SetEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34800          { (char *)"ComboBox_SetInsertionPointEnd", (PyCFunction) _wrap_ComboBox_SetInsertionPointEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34801          { (char *)"ComboBox_Remove", (PyCFunction) _wrap_ComboBox_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
34802          { (char *)"ComboBox_IsEditable", (PyCFunction) _wrap_ComboBox_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34803          { (char *)"ComboBox_Undo", (PyCFunction) _wrap_ComboBox_Undo, METH_VARARGS | METH_KEYWORDS, NULL},
34804          { (char *)"ComboBox_Redo", (PyCFunction) _wrap_ComboBox_Redo, METH_VARARGS | METH_KEYWORDS, NULL},
34805          { (char *)"ComboBox_SelectAll", (PyCFunction) _wrap_ComboBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34806          { (char *)"ComboBox_CanCopy", (PyCFunction) _wrap_ComboBox_CanCopy, METH_VARARGS | METH_KEYWORDS, NULL},
34807          { (char *)"ComboBox_CanCut", (PyCFunction) _wrap_ComboBox_CanCut, METH_VARARGS | METH_KEYWORDS, NULL},
34808          { (char *)"ComboBox_CanPaste", (PyCFunction) _wrap_ComboBox_CanPaste, METH_VARARGS | METH_KEYWORDS, NULL},
34809          { (char *)"ComboBox_CanUndo", (PyCFunction) _wrap_ComboBox_CanUndo, METH_VARARGS | METH_KEYWORDS, NULL},
34810          { (char *)"ComboBox_CanRedo", (PyCFunction) _wrap_ComboBox_CanRedo, METH_VARARGS | METH_KEYWORDS, NULL},
34811          { (char *)"ComboBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ComboBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34812          { (char *)"ComboBox_swigregister", ComboBox_swigregister, METH_VARARGS, NULL},
34813          { (char *)"new_Gauge", (PyCFunction) _wrap_new_Gauge, METH_VARARGS | METH_KEYWORDS, NULL},
34814          { (char *)"new_PreGauge", (PyCFunction) _wrap_new_PreGauge, METH_VARARGS | METH_KEYWORDS, NULL},
34815          { (char *)"Gauge_Create", (PyCFunction) _wrap_Gauge_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34816          { (char *)"Gauge_SetRange", (PyCFunction) _wrap_Gauge_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34817          { (char *)"Gauge_GetRange", (PyCFunction) _wrap_Gauge_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34818          { (char *)"Gauge_SetValue", (PyCFunction) _wrap_Gauge_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34819          { (char *)"Gauge_GetValue", (PyCFunction) _wrap_Gauge_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34820          { (char *)"Gauge_IsVertical", (PyCFunction) _wrap_Gauge_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34821          { (char *)"Gauge_SetShadowWidth", (PyCFunction) _wrap_Gauge_SetShadowWidth, METH_VARARGS | METH_KEYWORDS, NULL},
34822          { (char *)"Gauge_GetShadowWidth", (PyCFunction) _wrap_Gauge_GetShadowWidth, METH_VARARGS | METH_KEYWORDS, NULL},
34823          { (char *)"Gauge_SetBezelFace", (PyCFunction) _wrap_Gauge_SetBezelFace, METH_VARARGS | METH_KEYWORDS, NULL},
34824          { (char *)"Gauge_GetBezelFace", (PyCFunction) _wrap_Gauge_GetBezelFace, METH_VARARGS | METH_KEYWORDS, NULL},
34825          { (char *)"Gauge_GetClassDefaultAttributes", (PyCFunction) _wrap_Gauge_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34826          { (char *)"Gauge_swigregister", Gauge_swigregister, METH_VARARGS, NULL},
34827          { (char *)"new_StaticBox", (PyCFunction) _wrap_new_StaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
34828          { (char *)"new_PreStaticBox", (PyCFunction) _wrap_new_PreStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
34829          { (char *)"StaticBox_Create", (PyCFunction) _wrap_StaticBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34830          { (char *)"StaticBox_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34831          { (char *)"StaticBox_swigregister", StaticBox_swigregister, METH_VARARGS, NULL},
34832          { (char *)"new_StaticLine", (PyCFunction) _wrap_new_StaticLine, METH_VARARGS | METH_KEYWORDS, NULL},
34833          { (char *)"new_PreStaticLine", (PyCFunction) _wrap_new_PreStaticLine, METH_VARARGS | METH_KEYWORDS, NULL},
34834          { (char *)"StaticLine_Create", (PyCFunction) _wrap_StaticLine_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34835          { (char *)"StaticLine_IsVertical", (PyCFunction) _wrap_StaticLine_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34836          { (char *)"StaticLine_GetDefaultSize", (PyCFunction) _wrap_StaticLine_GetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
34837          { (char *)"StaticLine_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticLine_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34838          { (char *)"StaticLine_swigregister", StaticLine_swigregister, METH_VARARGS, NULL},
34839          { (char *)"new_StaticText", (PyCFunction) _wrap_new_StaticText, METH_VARARGS | METH_KEYWORDS, NULL},
34840          { (char *)"new_PreStaticText", (PyCFunction) _wrap_new_PreStaticText, METH_VARARGS | METH_KEYWORDS, NULL},
34841          { (char *)"StaticText_Create", (PyCFunction) _wrap_StaticText_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34842          { (char *)"StaticText_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticText_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34843          { (char *)"StaticText_swigregister", StaticText_swigregister, METH_VARARGS, NULL},
34844          { (char *)"new_StaticBitmap", (PyCFunction) _wrap_new_StaticBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34845          { (char *)"new_PreStaticBitmap", (PyCFunction) _wrap_new_PreStaticBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34846          { (char *)"StaticBitmap_Create", (PyCFunction) _wrap_StaticBitmap_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34847          { (char *)"StaticBitmap_GetBitmap", (PyCFunction) _wrap_StaticBitmap_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34848          { (char *)"StaticBitmap_SetBitmap", (PyCFunction) _wrap_StaticBitmap_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
34849          { (char *)"StaticBitmap_SetIcon", (PyCFunction) _wrap_StaticBitmap_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
34850          { (char *)"StaticBitmap_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBitmap_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34851          { (char *)"StaticBitmap_swigregister", StaticBitmap_swigregister, METH_VARARGS, NULL},
34852          { (char *)"new_ListBox", (PyCFunction) _wrap_new_ListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34853          { (char *)"new_PreListBox", (PyCFunction) _wrap_new_PreListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34854          { (char *)"ListBox_Create", (PyCFunction) _wrap_ListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34855          { (char *)"ListBox_Insert", (PyCFunction) _wrap_ListBox_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
34856          { (char *)"ListBox_InsertItems", (PyCFunction) _wrap_ListBox_InsertItems, METH_VARARGS | METH_KEYWORDS, NULL},
34857          { (char *)"ListBox_Set", (PyCFunction) _wrap_ListBox_Set, METH_VARARGS | METH_KEYWORDS, NULL},
34858          { (char *)"ListBox_IsSelected", (PyCFunction) _wrap_ListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
34859          { (char *)"ListBox_SetSelection", (PyCFunction) _wrap_ListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34860          { (char *)"ListBox_Select", (PyCFunction) _wrap_ListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
34861          { (char *)"ListBox_Deselect", (PyCFunction) _wrap_ListBox_Deselect, METH_VARARGS | METH_KEYWORDS, NULL},
34862          { (char *)"ListBox_DeselectAll", (PyCFunction) _wrap_ListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34863          { (char *)"ListBox_SetStringSelection", (PyCFunction) _wrap_ListBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34864          { (char *)"ListBox_GetSelections", (PyCFunction) _wrap_ListBox_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
34865          { (char *)"ListBox_SetFirstItem", (PyCFunction) _wrap_ListBox_SetFirstItem, METH_VARARGS | METH_KEYWORDS, NULL},
34866          { (char *)"ListBox_SetFirstItemStr", (PyCFunction) _wrap_ListBox_SetFirstItemStr, METH_VARARGS | METH_KEYWORDS, NULL},
34867          { (char *)"ListBox_EnsureVisible", (PyCFunction) _wrap_ListBox_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
34868          { (char *)"ListBox_AppendAndEnsureVisible", (PyCFunction) _wrap_ListBox_AppendAndEnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
34869          { (char *)"ListBox_IsSorted", (PyCFunction) _wrap_ListBox_IsSorted, METH_VARARGS | METH_KEYWORDS, NULL},
34870          { (char *)"ListBox_SetItemForegroundColour", (PyCFunction) _wrap_ListBox_SetItemForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34871          { (char *)"ListBox_SetItemBackgroundColour", (PyCFunction) _wrap_ListBox_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34872          { (char *)"ListBox_SetItemFont", (PyCFunction) _wrap_ListBox_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
34873          { (char *)"ListBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ListBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34874          { (char *)"ListBox_swigregister", ListBox_swigregister, METH_VARARGS, NULL},
34875          { (char *)"new_CheckListBox", (PyCFunction) _wrap_new_CheckListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34876          { (char *)"new_PreCheckListBox", (PyCFunction) _wrap_new_PreCheckListBox, METH_VARARGS | METH_KEYWORDS, NULL},
34877          { (char *)"CheckListBox_Create", (PyCFunction) _wrap_CheckListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34878          { (char *)"CheckListBox_IsChecked", (PyCFunction) _wrap_CheckListBox_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
34879          { (char *)"CheckListBox_Check", (PyCFunction) _wrap_CheckListBox_Check, METH_VARARGS | METH_KEYWORDS, NULL},
34880          { (char *)"CheckListBox_GetItemHeight", (PyCFunction) _wrap_CheckListBox_GetItemHeight, METH_VARARGS | METH_KEYWORDS, NULL},
34881          { (char *)"CheckListBox_HitTest", (PyCFunction) _wrap_CheckListBox_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
34882          { (char *)"CheckListBox_HitTestXY", (PyCFunction) _wrap_CheckListBox_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
34883          { (char *)"CheckListBox_swigregister", CheckListBox_swigregister, METH_VARARGS, NULL},
34884          { (char *)"new_TextAttr", (PyCFunction) _wrap_new_TextAttr, METH_VARARGS | METH_KEYWORDS, NULL},
34885          { (char *)"delete_TextAttr", (PyCFunction) _wrap_delete_TextAttr, METH_VARARGS | METH_KEYWORDS, NULL},
34886          { (char *)"TextAttr_Init", (PyCFunction) _wrap_TextAttr_Init, METH_VARARGS | METH_KEYWORDS, NULL},
34887          { (char *)"TextAttr_SetTextColour", (PyCFunction) _wrap_TextAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34888          { (char *)"TextAttr_SetBackgroundColour", (PyCFunction) _wrap_TextAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34889          { (char *)"TextAttr_SetFont", (PyCFunction) _wrap_TextAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
34890          { (char *)"TextAttr_SetAlignment", (PyCFunction) _wrap_TextAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34891          { (char *)"TextAttr_SetTabs", (PyCFunction) _wrap_TextAttr_SetTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34892          { (char *)"TextAttr_SetLeftIndent", (PyCFunction) _wrap_TextAttr_SetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34893          { (char *)"TextAttr_SetRightIndent", (PyCFunction) _wrap_TextAttr_SetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34894          { (char *)"TextAttr_SetFlags", (PyCFunction) _wrap_TextAttr_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
34895          { (char *)"TextAttr_HasTextColour", (PyCFunction) _wrap_TextAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34896          { (char *)"TextAttr_HasBackgroundColour", (PyCFunction) _wrap_TextAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34897          { (char *)"TextAttr_HasFont", (PyCFunction) _wrap_TextAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
34898          { (char *)"TextAttr_HasAlignment", (PyCFunction) _wrap_TextAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34899          { (char *)"TextAttr_HasTabs", (PyCFunction) _wrap_TextAttr_HasTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34900          { (char *)"TextAttr_HasLeftIndent", (PyCFunction) _wrap_TextAttr_HasLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34901          { (char *)"TextAttr_HasRightIndent", (PyCFunction) _wrap_TextAttr_HasRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34902          { (char *)"TextAttr_HasFlag", (PyCFunction) _wrap_TextAttr_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
34903          { (char *)"TextAttr_GetTextColour", (PyCFunction) _wrap_TextAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
34904          { (char *)"TextAttr_GetBackgroundColour", (PyCFunction) _wrap_TextAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
34905          { (char *)"TextAttr_GetFont", (PyCFunction) _wrap_TextAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
34906          { (char *)"TextAttr_GetAlignment", (PyCFunction) _wrap_TextAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
34907          { (char *)"TextAttr_GetTabs", (PyCFunction) _wrap_TextAttr_GetTabs, METH_VARARGS | METH_KEYWORDS, NULL},
34908          { (char *)"TextAttr_GetLeftIndent", (PyCFunction) _wrap_TextAttr_GetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34909          { (char *)"TextAttr_GetLeftSubIndent", (PyCFunction) _wrap_TextAttr_GetLeftSubIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34910          { (char *)"TextAttr_GetRightIndent", (PyCFunction) _wrap_TextAttr_GetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
34911          { (char *)"TextAttr_GetFlags", (PyCFunction) _wrap_TextAttr_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
34912          { (char *)"TextAttr_IsDefault", (PyCFunction) _wrap_TextAttr_IsDefault, METH_VARARGS | METH_KEYWORDS, NULL},
34913          { (char *)"TextAttr_Combine", (PyCFunction) _wrap_TextAttr_Combine, METH_VARARGS | METH_KEYWORDS, NULL},
34914          { (char *)"TextAttr_swigregister", TextAttr_swigregister, METH_VARARGS, NULL},
34915          { (char *)"new_TextCtrl", (PyCFunction) _wrap_new_TextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34916          { (char *)"new_PreTextCtrl", (PyCFunction) _wrap_new_PreTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
34917          { (char *)"TextCtrl_Create", (PyCFunction) _wrap_TextCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34918          { (char *)"TextCtrl_GetValue", (PyCFunction) _wrap_TextCtrl_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34919          { (char *)"TextCtrl_SetValue", (PyCFunction) _wrap_TextCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34920          { (char *)"TextCtrl_GetRange", (PyCFunction) _wrap_TextCtrl_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34921          { (char *)"TextCtrl_GetLineLength", (PyCFunction) _wrap_TextCtrl_GetLineLength, METH_VARARGS | METH_KEYWORDS, NULL},
34922          { (char *)"TextCtrl_GetLineText", (PyCFunction) _wrap_TextCtrl_GetLineText, METH_VARARGS | METH_KEYWORDS, NULL},
34923          { (char *)"TextCtrl_GetNumberOfLines", (PyCFunction) _wrap_TextCtrl_GetNumberOfLines, METH_VARARGS | METH_KEYWORDS, NULL},
34924          { (char *)"TextCtrl_IsModified", (PyCFunction) _wrap_TextCtrl_IsModified, METH_VARARGS | METH_KEYWORDS, NULL},
34925          { (char *)"TextCtrl_IsEditable", (PyCFunction) _wrap_TextCtrl_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34926          { (char *)"TextCtrl_IsSingleLine", (PyCFunction) _wrap_TextCtrl_IsSingleLine, METH_VARARGS | METH_KEYWORDS, NULL},
34927          { (char *)"TextCtrl_IsMultiLine", (PyCFunction) _wrap_TextCtrl_IsMultiLine, METH_VARARGS | METH_KEYWORDS, NULL},
34928          { (char *)"TextCtrl_GetSelection", (PyCFunction) _wrap_TextCtrl_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34929          { (char *)"TextCtrl_GetStringSelection", (PyCFunction) _wrap_TextCtrl_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34930          { (char *)"TextCtrl_Clear", (PyCFunction) _wrap_TextCtrl_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
34931          { (char *)"TextCtrl_Replace", (PyCFunction) _wrap_TextCtrl_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
34932          { (char *)"TextCtrl_Remove", (PyCFunction) _wrap_TextCtrl_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
34933          { (char *)"TextCtrl_LoadFile", (PyCFunction) _wrap_TextCtrl_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
34934          { (char *)"TextCtrl_SaveFile", (PyCFunction) _wrap_TextCtrl_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
34935          { (char *)"TextCtrl_MarkDirty", (PyCFunction) _wrap_TextCtrl_MarkDirty, METH_VARARGS | METH_KEYWORDS, NULL},
34936          { (char *)"TextCtrl_DiscardEdits", (PyCFunction) _wrap_TextCtrl_DiscardEdits, METH_VARARGS | METH_KEYWORDS, NULL},
34937          { (char *)"TextCtrl_SetMaxLength", (PyCFunction) _wrap_TextCtrl_SetMaxLength, METH_VARARGS | METH_KEYWORDS, NULL},
34938          { (char *)"TextCtrl_WriteText", (PyCFunction) _wrap_TextCtrl_WriteText, METH_VARARGS | METH_KEYWORDS, NULL},
34939          { (char *)"TextCtrl_AppendText", (PyCFunction) _wrap_TextCtrl_AppendText, METH_VARARGS | METH_KEYWORDS, NULL},
34940          { (char *)"TextCtrl_EmulateKeyPress", (PyCFunction) _wrap_TextCtrl_EmulateKeyPress, METH_VARARGS | METH_KEYWORDS, NULL},
34941          { (char *)"TextCtrl_SetStyle", (PyCFunction) _wrap_TextCtrl_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34942          { (char *)"TextCtrl_GetStyle", (PyCFunction) _wrap_TextCtrl_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34943          { (char *)"TextCtrl_SetDefaultStyle", (PyCFunction) _wrap_TextCtrl_SetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34944          { (char *)"TextCtrl_GetDefaultStyle", (PyCFunction) _wrap_TextCtrl_GetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},
34945          { (char *)"TextCtrl_XYToPosition", (PyCFunction) _wrap_TextCtrl_XYToPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34946          { (char *)"TextCtrl_PositionToXY", (PyCFunction) _wrap_TextCtrl_PositionToXY, METH_VARARGS | METH_KEYWORDS, NULL},
34947          { (char *)"TextCtrl_ShowPosition", (PyCFunction) _wrap_TextCtrl_ShowPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34948          { (char *)"TextCtrl_HitTest", (PyCFunction) _wrap_TextCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
34949          { (char *)"TextCtrl_HitTestPos", (PyCFunction) _wrap_TextCtrl_HitTestPos, METH_VARARGS | METH_KEYWORDS, NULL},
34950          { (char *)"TextCtrl_Copy", (PyCFunction) _wrap_TextCtrl_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
34951          { (char *)"TextCtrl_Cut", (PyCFunction) _wrap_TextCtrl_Cut, METH_VARARGS | METH_KEYWORDS, NULL},
34952          { (char *)"TextCtrl_Paste", (PyCFunction) _wrap_TextCtrl_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
34953          { (char *)"TextCtrl_CanCopy", (PyCFunction) _wrap_TextCtrl_CanCopy, METH_VARARGS | METH_KEYWORDS, NULL},
34954          { (char *)"TextCtrl_CanCut", (PyCFunction) _wrap_TextCtrl_CanCut, METH_VARARGS | METH_KEYWORDS, NULL},
34955          { (char *)"TextCtrl_CanPaste", (PyCFunction) _wrap_TextCtrl_CanPaste, METH_VARARGS | METH_KEYWORDS, NULL},
34956          { (char *)"TextCtrl_Undo", (PyCFunction) _wrap_TextCtrl_Undo, METH_VARARGS | METH_KEYWORDS, NULL},
34957          { (char *)"TextCtrl_Redo", (PyCFunction) _wrap_TextCtrl_Redo, METH_VARARGS | METH_KEYWORDS, NULL},
34958          { (char *)"TextCtrl_CanUndo", (PyCFunction) _wrap_TextCtrl_CanUndo, METH_VARARGS | METH_KEYWORDS, NULL},
34959          { (char *)"TextCtrl_CanRedo", (PyCFunction) _wrap_TextCtrl_CanRedo, METH_VARARGS | METH_KEYWORDS, NULL},
34960          { (char *)"TextCtrl_SetInsertionPoint", (PyCFunction) _wrap_TextCtrl_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34961          { (char *)"TextCtrl_SetInsertionPointEnd", (PyCFunction) _wrap_TextCtrl_SetInsertionPointEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34962          { (char *)"TextCtrl_GetInsertionPoint", (PyCFunction) _wrap_TextCtrl_GetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},
34963          { (char *)"TextCtrl_GetLastPosition", (PyCFunction) _wrap_TextCtrl_GetLastPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34964          { (char *)"TextCtrl_SetSelection", (PyCFunction) _wrap_TextCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
34965          { (char *)"TextCtrl_SelectAll", (PyCFunction) _wrap_TextCtrl_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
34966          { (char *)"TextCtrl_SetEditable", (PyCFunction) _wrap_TextCtrl_SetEditable, METH_VARARGS | METH_KEYWORDS, NULL},
34967          { (char *)"TextCtrl_ShowNativeCaret", (PyCFunction) _wrap_TextCtrl_ShowNativeCaret, METH_VARARGS | METH_KEYWORDS, NULL},
34968          { (char *)"TextCtrl_HideNativeCaret", (PyCFunction) _wrap_TextCtrl_HideNativeCaret, METH_VARARGS | METH_KEYWORDS, NULL},
34969          { (char *)"TextCtrl_write", (PyCFunction) _wrap_TextCtrl_write, METH_VARARGS | METH_KEYWORDS, NULL},
34970          { (char *)"TextCtrl_GetString", (PyCFunction) _wrap_TextCtrl_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
34971          { (char *)"TextCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TextCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34972          { (char *)"TextCtrl_swigregister", TextCtrl_swigregister, METH_VARARGS, NULL},
34973          { (char *)"new_TextUrlEvent", (PyCFunction) _wrap_new_TextUrlEvent, METH_VARARGS | METH_KEYWORDS, NULL},
34974          { (char *)"TextUrlEvent_GetMouseEvent", (PyCFunction) _wrap_TextUrlEvent_GetMouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
34975          { (char *)"TextUrlEvent_GetURLStart", (PyCFunction) _wrap_TextUrlEvent_GetURLStart, METH_VARARGS | METH_KEYWORDS, NULL},
34976          { (char *)"TextUrlEvent_GetURLEnd", (PyCFunction) _wrap_TextUrlEvent_GetURLEnd, METH_VARARGS | METH_KEYWORDS, NULL},
34977          { (char *)"TextUrlEvent_swigregister", TextUrlEvent_swigregister, METH_VARARGS, NULL},
34978          { (char *)"new_ScrollBar", (PyCFunction) _wrap_new_ScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},
34979          { (char *)"new_PreScrollBar", (PyCFunction) _wrap_new_PreScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},
34980          { (char *)"ScrollBar_Create", (PyCFunction) _wrap_ScrollBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34981          { (char *)"ScrollBar_GetThumbPosition", (PyCFunction) _wrap_ScrollBar_GetThumbPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34982          { (char *)"ScrollBar_GetThumbSize", (PyCFunction) _wrap_ScrollBar_GetThumbSize, METH_VARARGS | METH_KEYWORDS, NULL},
34983          { (char *)"ScrollBar_GetPageSize", (PyCFunction) _wrap_ScrollBar_GetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
34984          { (char *)"ScrollBar_GetRange", (PyCFunction) _wrap_ScrollBar_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},
34985          { (char *)"ScrollBar_IsVertical", (PyCFunction) _wrap_ScrollBar_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
34986          { (char *)"ScrollBar_SetThumbPosition", (PyCFunction) _wrap_ScrollBar_SetThumbPosition, METH_VARARGS | METH_KEYWORDS, NULL},
34987          { (char *)"ScrollBar_SetScrollbar", (PyCFunction) _wrap_ScrollBar_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
34988          { (char *)"ScrollBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrollBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
34989          { (char *)"ScrollBar_swigregister", ScrollBar_swigregister, METH_VARARGS, NULL},
34990          { (char *)"new_SpinButton", (PyCFunction) _wrap_new_SpinButton, METH_VARARGS | METH_KEYWORDS, NULL},
34991          { (char *)"new_PreSpinButton", (PyCFunction) _wrap_new_PreSpinButton, METH_VARARGS | METH_KEYWORDS, NULL},
34992          { (char *)"SpinButton_Create", (PyCFunction) _wrap_SpinButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
34993          { (char *)"SpinButton_GetValue", (PyCFunction) _wrap_SpinButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34994          { (char *)"SpinButton_GetMin", (PyCFunction) _wrap_SpinButton_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
34995          { (char *)"SpinButton_GetMax", (PyCFunction) _wrap_SpinButton_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
34996          { (char *)"SpinButton_SetValue", (PyCFunction) _wrap_SpinButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
34997          { (char *)"SpinButton_SetMin", (PyCFunction) _wrap_SpinButton_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
34998          { (char *)"SpinButton_SetMax", (PyCFunction) _wrap_SpinButton_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
34999          { (char *)"SpinButton_SetRange", (PyCFunction) _wrap_SpinButton_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
35000          { (char *)"SpinButton_IsVertical", (PyCFunction) _wrap_SpinButton_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35001          { (char *)"SpinButton_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35002          { (char *)"SpinButton_swigregister", SpinButton_swigregister, METH_VARARGS, NULL},
35003          { (char *)"new_SpinCtrl", (PyCFunction) _wrap_new_SpinCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35004          { (char *)"new_PreSpinCtrl", (PyCFunction) _wrap_new_PreSpinCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35005          { (char *)"SpinCtrl_Create", (PyCFunction) _wrap_SpinCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35006          { (char *)"SpinCtrl_GetValue", (PyCFunction) _wrap_SpinCtrl_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35007          { (char *)"SpinCtrl_SetValue", (PyCFunction) _wrap_SpinCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35008          { (char *)"SpinCtrl_SetValueString", (PyCFunction) _wrap_SpinCtrl_SetValueString, METH_VARARGS | METH_KEYWORDS, NULL},
35009          { (char *)"SpinCtrl_SetRange", (PyCFunction) _wrap_SpinCtrl_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
35010          { (char *)"SpinCtrl_GetMin", (PyCFunction) _wrap_SpinCtrl_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
35011          { (char *)"SpinCtrl_GetMax", (PyCFunction) _wrap_SpinCtrl_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
35012          { (char *)"SpinCtrl_SetSelection", (PyCFunction) _wrap_SpinCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35013          { (char *)"SpinCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35014          { (char *)"SpinCtrl_swigregister", SpinCtrl_swigregister, METH_VARARGS, NULL},
35015          { (char *)"new_SpinEvent", (PyCFunction) _wrap_new_SpinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35016          { (char *)"SpinEvent_GetPosition", (PyCFunction) _wrap_SpinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35017          { (char *)"SpinEvent_SetPosition", (PyCFunction) _wrap_SpinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35018          { (char *)"SpinEvent_swigregister", SpinEvent_swigregister, METH_VARARGS, NULL},
35019          { (char *)"new_RadioBox", (PyCFunction) _wrap_new_RadioBox, METH_VARARGS | METH_KEYWORDS, NULL},
35020          { (char *)"new_PreRadioBox", (PyCFunction) _wrap_new_PreRadioBox, METH_VARARGS | METH_KEYWORDS, NULL},
35021          { (char *)"RadioBox_Create", (PyCFunction) _wrap_RadioBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35022          { (char *)"RadioBox_SetSelection", (PyCFunction) _wrap_RadioBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35023          { (char *)"RadioBox_GetSelection", (PyCFunction) _wrap_RadioBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35024          { (char *)"RadioBox_GetStringSelection", (PyCFunction) _wrap_RadioBox_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35025          { (char *)"RadioBox_SetStringSelection", (PyCFunction) _wrap_RadioBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35026          { (char *)"RadioBox_GetCount", (PyCFunction) _wrap_RadioBox_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
35027          { (char *)"RadioBox_FindString", (PyCFunction) _wrap_RadioBox_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
35028          { (char *)"RadioBox_GetString", (PyCFunction) _wrap_RadioBox_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
35029          { (char *)"RadioBox_SetString", (PyCFunction) _wrap_RadioBox_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
35030          { (char *)"RadioBox_EnableItem", (PyCFunction) _wrap_RadioBox_EnableItem, METH_VARARGS | METH_KEYWORDS, NULL},
35031          { (char *)"RadioBox_ShowItem", (PyCFunction) _wrap_RadioBox_ShowItem, METH_VARARGS | METH_KEYWORDS, NULL},
35032          { (char *)"RadioBox_GetColumnCount", (PyCFunction) _wrap_RadioBox_GetColumnCount, METH_VARARGS | METH_KEYWORDS, NULL},
35033          { (char *)"RadioBox_GetRowCount", (PyCFunction) _wrap_RadioBox_GetRowCount, METH_VARARGS | METH_KEYWORDS, NULL},
35034          { (char *)"RadioBox_GetNextItem", (PyCFunction) _wrap_RadioBox_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
35035          { (char *)"RadioBox_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35036          { (char *)"RadioBox_swigregister", RadioBox_swigregister, METH_VARARGS, NULL},
35037          { (char *)"new_RadioButton", (PyCFunction) _wrap_new_RadioButton, METH_VARARGS | METH_KEYWORDS, NULL},
35038          { (char *)"new_PreRadioButton", (PyCFunction) _wrap_new_PreRadioButton, METH_VARARGS | METH_KEYWORDS, NULL},
35039          { (char *)"RadioButton_Create", (PyCFunction) _wrap_RadioButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35040          { (char *)"RadioButton_GetValue", (PyCFunction) _wrap_RadioButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35041          { (char *)"RadioButton_SetValue", (PyCFunction) _wrap_RadioButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35042          { (char *)"RadioButton_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35043          { (char *)"RadioButton_swigregister", RadioButton_swigregister, METH_VARARGS, NULL},
35044          { (char *)"new_Slider", (PyCFunction) _wrap_new_Slider, METH_VARARGS | METH_KEYWORDS, NULL},
35045          { (char *)"new_PreSlider", (PyCFunction) _wrap_new_PreSlider, METH_VARARGS | METH_KEYWORDS, NULL},
35046          { (char *)"Slider_Create", (PyCFunction) _wrap_Slider_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35047          { (char *)"Slider_GetValue", (PyCFunction) _wrap_Slider_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35048          { (char *)"Slider_SetValue", (PyCFunction) _wrap_Slider_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35049          { (char *)"Slider_SetRange", (PyCFunction) _wrap_Slider_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
35050          { (char *)"Slider_GetMin", (PyCFunction) _wrap_Slider_GetMin, METH_VARARGS | METH_KEYWORDS, NULL},
35051          { (char *)"Slider_GetMax", (PyCFunction) _wrap_Slider_GetMax, METH_VARARGS | METH_KEYWORDS, NULL},
35052          { (char *)"Slider_SetMin", (PyCFunction) _wrap_Slider_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
35053          { (char *)"Slider_SetMax", (PyCFunction) _wrap_Slider_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
35054          { (char *)"Slider_SetLineSize", (PyCFunction) _wrap_Slider_SetLineSize, METH_VARARGS | METH_KEYWORDS, NULL},
35055          { (char *)"Slider_SetPageSize", (PyCFunction) _wrap_Slider_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35056          { (char *)"Slider_GetLineSize", (PyCFunction) _wrap_Slider_GetLineSize, METH_VARARGS | METH_KEYWORDS, NULL},
35057          { (char *)"Slider_GetPageSize", (PyCFunction) _wrap_Slider_GetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35058          { (char *)"Slider_SetThumbLength", (PyCFunction) _wrap_Slider_SetThumbLength, METH_VARARGS | METH_KEYWORDS, NULL},
35059          { (char *)"Slider_GetThumbLength", (PyCFunction) _wrap_Slider_GetThumbLength, METH_VARARGS | METH_KEYWORDS, NULL},
35060          { (char *)"Slider_SetTickFreq", (PyCFunction) _wrap_Slider_SetTickFreq, METH_VARARGS | METH_KEYWORDS, NULL},
35061          { (char *)"Slider_GetTickFreq", (PyCFunction) _wrap_Slider_GetTickFreq, METH_VARARGS | METH_KEYWORDS, NULL},
35062          { (char *)"Slider_ClearTicks", (PyCFunction) _wrap_Slider_ClearTicks, METH_VARARGS | METH_KEYWORDS, NULL},
35063          { (char *)"Slider_SetTick", (PyCFunction) _wrap_Slider_SetTick, METH_VARARGS | METH_KEYWORDS, NULL},
35064          { (char *)"Slider_ClearSel", (PyCFunction) _wrap_Slider_ClearSel, METH_VARARGS | METH_KEYWORDS, NULL},
35065          { (char *)"Slider_GetSelEnd", (PyCFunction) _wrap_Slider_GetSelEnd, METH_VARARGS | METH_KEYWORDS, NULL},
35066          { (char *)"Slider_GetSelStart", (PyCFunction) _wrap_Slider_GetSelStart, METH_VARARGS | METH_KEYWORDS, NULL},
35067          { (char *)"Slider_SetSelection", (PyCFunction) _wrap_Slider_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35068          { (char *)"Slider_GetClassDefaultAttributes", (PyCFunction) _wrap_Slider_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35069          { (char *)"Slider_swigregister", Slider_swigregister, METH_VARARGS, NULL},
35070          { (char *)"new_ToggleButton", (PyCFunction) _wrap_new_ToggleButton, METH_VARARGS | METH_KEYWORDS, NULL},
35071          { (char *)"new_PreToggleButton", (PyCFunction) _wrap_new_PreToggleButton, METH_VARARGS | METH_KEYWORDS, NULL},
35072          { (char *)"ToggleButton_Create", (PyCFunction) _wrap_ToggleButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35073          { (char *)"ToggleButton_SetValue", (PyCFunction) _wrap_ToggleButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35074          { (char *)"ToggleButton_GetValue", (PyCFunction) _wrap_ToggleButton_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
35075          { (char *)"ToggleButton_SetLabel", (PyCFunction) _wrap_ToggleButton_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35076          { (char *)"ToggleButton_GetClassDefaultAttributes", (PyCFunction) _wrap_ToggleButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35077          { (char *)"ToggleButton_swigregister", ToggleButton_swigregister, METH_VARARGS, NULL},
35078          { (char *)"BookCtrlBase_GetPageCount", (PyCFunction) _wrap_BookCtrlBase_GetPageCount, METH_VARARGS | METH_KEYWORDS, NULL},
35079          { (char *)"BookCtrlBase_GetPage", (PyCFunction) _wrap_BookCtrlBase_GetPage, METH_VARARGS | METH_KEYWORDS, NULL},
35080          { (char *)"BookCtrlBase_GetCurrentPage", (PyCFunction) _wrap_BookCtrlBase_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
35081          { (char *)"BookCtrlBase_GetSelection", (PyCFunction) _wrap_BookCtrlBase_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35082          { (char *)"BookCtrlBase_SetPageText", (PyCFunction) _wrap_BookCtrlBase_SetPageText, METH_VARARGS | METH_KEYWORDS, NULL},
35083          { (char *)"BookCtrlBase_GetPageText", (PyCFunction) _wrap_BookCtrlBase_GetPageText, METH_VARARGS | METH_KEYWORDS, NULL},
35084          { (char *)"BookCtrlBase_SetImageList", (PyCFunction) _wrap_BookCtrlBase_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35085          { (char *)"BookCtrlBase_AssignImageList", (PyCFunction) _wrap_BookCtrlBase_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35086          { (char *)"BookCtrlBase_GetImageList", (PyCFunction) _wrap_BookCtrlBase_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35087          { (char *)"BookCtrlBase_GetPageImage", (PyCFunction) _wrap_BookCtrlBase_GetPageImage, METH_VARARGS | METH_KEYWORDS, NULL},
35088          { (char *)"BookCtrlBase_SetPageImage", (PyCFunction) _wrap_BookCtrlBase_SetPageImage, METH_VARARGS | METH_KEYWORDS, NULL},
35089          { (char *)"BookCtrlBase_SetPageSize", (PyCFunction) _wrap_BookCtrlBase_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
35090          { (char *)"BookCtrlBase_CalcSizeFromPage", (PyCFunction) _wrap_BookCtrlBase_CalcSizeFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
35091          { (char *)"BookCtrlBase_DeletePage", (PyCFunction) _wrap_BookCtrlBase_DeletePage, METH_VARARGS | METH_KEYWORDS, NULL},
35092          { (char *)"BookCtrlBase_RemovePage", (PyCFunction) _wrap_BookCtrlBase_RemovePage, METH_VARARGS | METH_KEYWORDS, NULL},
35093          { (char *)"BookCtrlBase_DeleteAllPages", (PyCFunction) _wrap_BookCtrlBase_DeleteAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
35094          { (char *)"BookCtrlBase_AddPage", (PyCFunction) _wrap_BookCtrlBase_AddPage, METH_VARARGS | METH_KEYWORDS, NULL},
35095          { (char *)"BookCtrlBase_InsertPage", (PyCFunction) _wrap_BookCtrlBase_InsertPage, METH_VARARGS | METH_KEYWORDS, NULL},
35096          { (char *)"BookCtrlBase_SetSelection", (PyCFunction) _wrap_BookCtrlBase_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35097          { (char *)"BookCtrlBase_AdvanceSelection", (PyCFunction) _wrap_BookCtrlBase_AdvanceSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35098          { (char *)"BookCtrlBase_GetClassDefaultAttributes", (PyCFunction) _wrap_BookCtrlBase_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35099          { (char *)"BookCtrlBase_swigregister", BookCtrlBase_swigregister, METH_VARARGS, NULL},
35100          { (char *)"new_BookCtrlBaseEvent", (PyCFunction) _wrap_new_BookCtrlBaseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35101          { (char *)"BookCtrlBaseEvent_GetSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35102          { (char *)"BookCtrlBaseEvent_SetSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35103          { (char *)"BookCtrlBaseEvent_GetOldSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_GetOldSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35104          { (char *)"BookCtrlBaseEvent_SetOldSelection", (PyCFunction) _wrap_BookCtrlBaseEvent_SetOldSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35105          { (char *)"BookCtrlBaseEvent_swigregister", BookCtrlBaseEvent_swigregister, METH_VARARGS, NULL},
35106          { (char *)"new_Notebook", (PyCFunction) _wrap_new_Notebook, METH_VARARGS | METH_KEYWORDS, NULL},
35107          { (char *)"new_PreNotebook", (PyCFunction) _wrap_new_PreNotebook, METH_VARARGS | METH_KEYWORDS, NULL},
35108          { (char *)"Notebook_Create", (PyCFunction) _wrap_Notebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35109          { (char *)"Notebook_GetRowCount", (PyCFunction) _wrap_Notebook_GetRowCount, METH_VARARGS | METH_KEYWORDS, NULL},
35110          { (char *)"Notebook_SetPadding", (PyCFunction) _wrap_Notebook_SetPadding, METH_VARARGS | METH_KEYWORDS, NULL},
35111          { (char *)"Notebook_SetTabSize", (PyCFunction) _wrap_Notebook_SetTabSize, METH_VARARGS | METH_KEYWORDS, NULL},
35112          { (char *)"Notebook_HitTest", (PyCFunction) _wrap_Notebook_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35113          { (char *)"Notebook_CalcSizeFromPage", (PyCFunction) _wrap_Notebook_CalcSizeFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
35114          { (char *)"Notebook_GetThemeBackgroundColour", (PyCFunction) _wrap_Notebook_GetThemeBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35115          { (char *)"Notebook_GetClassDefaultAttributes", (PyCFunction) _wrap_Notebook_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35116          { (char *)"Notebook_swigregister", Notebook_swigregister, METH_VARARGS, NULL},
35117          { (char *)"new_NotebookEvent", (PyCFunction) _wrap_new_NotebookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35118          { (char *)"NotebookEvent_swigregister", NotebookEvent_swigregister, METH_VARARGS, NULL},
35119          { (char *)"new_Listbook", (PyCFunction) _wrap_new_Listbook, METH_VARARGS | METH_KEYWORDS, NULL},
35120          { (char *)"new_PreListbook", (PyCFunction) _wrap_new_PreListbook, METH_VARARGS | METH_KEYWORDS, NULL},
35121          { (char *)"Listbook_Create", (PyCFunction) _wrap_Listbook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35122          { (char *)"Listbook_IsVertical", (PyCFunction) _wrap_Listbook_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35123          { (char *)"Listbook_GetListView", (PyCFunction) _wrap_Listbook_GetListView, METH_VARARGS | METH_KEYWORDS, NULL},
35124          { (char *)"Listbook_swigregister", Listbook_swigregister, METH_VARARGS, NULL},
35125          { (char *)"new_ListbookEvent", (PyCFunction) _wrap_new_ListbookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35126          { (char *)"ListbookEvent_swigregister", ListbookEvent_swigregister, METH_VARARGS, NULL},
35127          { (char *)"new_Choicebook", (PyCFunction) _wrap_new_Choicebook, METH_VARARGS | METH_KEYWORDS, NULL},
35128          { (char *)"new_PreChoicebook", (PyCFunction) _wrap_new_PreChoicebook, METH_VARARGS | METH_KEYWORDS, NULL},
35129          { (char *)"Choicebook_Create", (PyCFunction) _wrap_Choicebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35130          { (char *)"Choicebook_IsVertical", (PyCFunction) _wrap_Choicebook_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35131          { (char *)"Choicebook_DeleteAllPages", (PyCFunction) _wrap_Choicebook_DeleteAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
35132          { (char *)"Choicebook_swigregister", Choicebook_swigregister, METH_VARARGS, NULL},
35133          { (char *)"new_ChoicebookEvent", (PyCFunction) _wrap_new_ChoicebookEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35134          { (char *)"ChoicebookEvent_swigregister", ChoicebookEvent_swigregister, METH_VARARGS, NULL},
35135          { (char *)"new_BookCtrlSizer", (PyCFunction) _wrap_new_BookCtrlSizer, METH_VARARGS | METH_KEYWORDS, NULL},
35136          { (char *)"BookCtrlSizer_RecalcSizes", (PyCFunction) _wrap_BookCtrlSizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
35137          { (char *)"BookCtrlSizer_CalcMin", (PyCFunction) _wrap_BookCtrlSizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
35138          { (char *)"BookCtrlSizer_GetControl", (PyCFunction) _wrap_BookCtrlSizer_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
35139          { (char *)"BookCtrlSizer_swigregister", BookCtrlSizer_swigregister, METH_VARARGS, NULL},
35140          { (char *)"new_NotebookSizer", (PyCFunction) _wrap_new_NotebookSizer, METH_VARARGS | METH_KEYWORDS, NULL},
35141          { (char *)"NotebookSizer_RecalcSizes", (PyCFunction) _wrap_NotebookSizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
35142          { (char *)"NotebookSizer_CalcMin", (PyCFunction) _wrap_NotebookSizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
35143          { (char *)"NotebookSizer_GetNotebook", (PyCFunction) _wrap_NotebookSizer_GetNotebook, METH_VARARGS | METH_KEYWORDS, NULL},
35144          { (char *)"NotebookSizer_swigregister", NotebookSizer_swigregister, METH_VARARGS, NULL},
35145          { (char *)"ToolBarToolBase_GetId", (PyCFunction) _wrap_ToolBarToolBase_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35146          { (char *)"ToolBarToolBase_GetControl", (PyCFunction) _wrap_ToolBarToolBase_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
35147          { (char *)"ToolBarToolBase_GetToolBar", (PyCFunction) _wrap_ToolBarToolBase_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35148          { (char *)"ToolBarToolBase_IsButton", (PyCFunction) _wrap_ToolBarToolBase_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
35149          { (char *)"ToolBarToolBase_IsControl", (PyCFunction) _wrap_ToolBarToolBase_IsControl, METH_VARARGS | METH_KEYWORDS, NULL},
35150          { (char *)"ToolBarToolBase_IsSeparator", (PyCFunction) _wrap_ToolBarToolBase_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35151          { (char *)"ToolBarToolBase_GetStyle", (PyCFunction) _wrap_ToolBarToolBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
35152          { (char *)"ToolBarToolBase_GetKind", (PyCFunction) _wrap_ToolBarToolBase_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
35153          { (char *)"ToolBarToolBase_IsEnabled", (PyCFunction) _wrap_ToolBarToolBase_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
35154          { (char *)"ToolBarToolBase_IsToggled", (PyCFunction) _wrap_ToolBarToolBase_IsToggled, METH_VARARGS | METH_KEYWORDS, NULL},
35155          { (char *)"ToolBarToolBase_CanBeToggled", (PyCFunction) _wrap_ToolBarToolBase_CanBeToggled, METH_VARARGS | METH_KEYWORDS, NULL},
35156          { (char *)"ToolBarToolBase_GetNormalBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35157          { (char *)"ToolBarToolBase_GetDisabledBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35158          { (char *)"ToolBarToolBase_GetBitmap", (PyCFunction) _wrap_ToolBarToolBase_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35159          { (char *)"ToolBarToolBase_GetLabel", (PyCFunction) _wrap_ToolBarToolBase_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35160          { (char *)"ToolBarToolBase_GetShortHelp", (PyCFunction) _wrap_ToolBarToolBase_GetShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35161          { (char *)"ToolBarToolBase_GetLongHelp", (PyCFunction) _wrap_ToolBarToolBase_GetLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35162          { (char *)"ToolBarToolBase_Enable", (PyCFunction) _wrap_ToolBarToolBase_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35163          { (char *)"ToolBarToolBase_Toggle", (PyCFunction) _wrap_ToolBarToolBase_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
35164          { (char *)"ToolBarToolBase_SetToggle", (PyCFunction) _wrap_ToolBarToolBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
35165          { (char *)"ToolBarToolBase_SetShortHelp", (PyCFunction) _wrap_ToolBarToolBase_SetShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35166          { (char *)"ToolBarToolBase_SetLongHelp", (PyCFunction) _wrap_ToolBarToolBase_SetLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35167          { (char *)"ToolBarToolBase_SetNormalBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35168          { (char *)"ToolBarToolBase_SetDisabledBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35169          { (char *)"ToolBarToolBase_SetLabel", (PyCFunction) _wrap_ToolBarToolBase_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35170          { (char *)"ToolBarToolBase_Detach", (PyCFunction) _wrap_ToolBarToolBase_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
35171          { (char *)"ToolBarToolBase_Attach", (PyCFunction) _wrap_ToolBarToolBase_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
35172          { (char *)"ToolBarToolBase_GetClientData", (PyCFunction) _wrap_ToolBarToolBase_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35173          { (char *)"ToolBarToolBase_SetClientData", (PyCFunction) _wrap_ToolBarToolBase_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35174          { (char *)"ToolBarToolBase_swigregister", ToolBarToolBase_swigregister, METH_VARARGS, NULL},
35175          { (char *)"ToolBarBase_DoAddTool", (PyCFunction) _wrap_ToolBarBase_DoAddTool, METH_VARARGS | METH_KEYWORDS, NULL},
35176          { (char *)"ToolBarBase_DoInsertTool", (PyCFunction) _wrap_ToolBarBase_DoInsertTool, METH_VARARGS | METH_KEYWORDS, NULL},
35177          { (char *)"ToolBarBase_AddToolItem", (PyCFunction) _wrap_ToolBarBase_AddToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
35178          { (char *)"ToolBarBase_InsertToolItem", (PyCFunction) _wrap_ToolBarBase_InsertToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
35179          { (char *)"ToolBarBase_AddControl", (PyCFunction) _wrap_ToolBarBase_AddControl, METH_VARARGS | METH_KEYWORDS, NULL},
35180          { (char *)"ToolBarBase_InsertControl", (PyCFunction) _wrap_ToolBarBase_InsertControl, METH_VARARGS | METH_KEYWORDS, NULL},
35181          { (char *)"ToolBarBase_FindControl", (PyCFunction) _wrap_ToolBarBase_FindControl, METH_VARARGS | METH_KEYWORDS, NULL},
35182          { (char *)"ToolBarBase_AddSeparator", (PyCFunction) _wrap_ToolBarBase_AddSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35183          { (char *)"ToolBarBase_InsertSeparator", (PyCFunction) _wrap_ToolBarBase_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
35184          { (char *)"ToolBarBase_RemoveTool", (PyCFunction) _wrap_ToolBarBase_RemoveTool, METH_VARARGS | METH_KEYWORDS, NULL},
35185          { (char *)"ToolBarBase_DeleteToolByPos", (PyCFunction) _wrap_ToolBarBase_DeleteToolByPos, METH_VARARGS | METH_KEYWORDS, NULL},
35186          { (char *)"ToolBarBase_DeleteTool", (PyCFunction) _wrap_ToolBarBase_DeleteTool, METH_VARARGS | METH_KEYWORDS, NULL},
35187          { (char *)"ToolBarBase_ClearTools", (PyCFunction) _wrap_ToolBarBase_ClearTools, METH_VARARGS | METH_KEYWORDS, NULL},
35188          { (char *)"ToolBarBase_Realize", (PyCFunction) _wrap_ToolBarBase_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
35189          { (char *)"ToolBarBase_EnableTool", (PyCFunction) _wrap_ToolBarBase_EnableTool, METH_VARARGS | METH_KEYWORDS, NULL},
35190          { (char *)"ToolBarBase_ToggleTool", (PyCFunction) _wrap_ToolBarBase_ToggleTool, METH_VARARGS | METH_KEYWORDS, NULL},
35191          { (char *)"ToolBarBase_SetToggle", (PyCFunction) _wrap_ToolBarBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
35192          { (char *)"ToolBarBase_GetToolClientData", (PyCFunction) _wrap_ToolBarBase_GetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35193          { (char *)"ToolBarBase_SetToolClientData", (PyCFunction) _wrap_ToolBarBase_SetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
35194          { (char *)"ToolBarBase_GetToolPos", (PyCFunction) _wrap_ToolBarBase_GetToolPos, METH_VARARGS | METH_KEYWORDS, NULL},
35195          { (char *)"ToolBarBase_GetToolState", (PyCFunction) _wrap_ToolBarBase_GetToolState, METH_VARARGS | METH_KEYWORDS, NULL},
35196          { (char *)"ToolBarBase_GetToolEnabled", (PyCFunction) _wrap_ToolBarBase_GetToolEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
35197          { (char *)"ToolBarBase_SetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_SetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35198          { (char *)"ToolBarBase_GetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_GetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35199          { (char *)"ToolBarBase_SetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_SetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35200          { (char *)"ToolBarBase_GetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_GetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35201          { (char *)"ToolBarBase_SetMarginsXY", (PyCFunction) _wrap_ToolBarBase_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
35202          { (char *)"ToolBarBase_SetMargins", (PyCFunction) _wrap_ToolBarBase_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35203          { (char *)"ToolBarBase_SetToolPacking", (PyCFunction) _wrap_ToolBarBase_SetToolPacking, METH_VARARGS | METH_KEYWORDS, NULL},
35204          { (char *)"ToolBarBase_SetToolSeparation", (PyCFunction) _wrap_ToolBarBase_SetToolSeparation, METH_VARARGS | METH_KEYWORDS, NULL},
35205          { (char *)"ToolBarBase_GetToolMargins", (PyCFunction) _wrap_ToolBarBase_GetToolMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35206          { (char *)"ToolBarBase_GetMargins", (PyCFunction) _wrap_ToolBarBase_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
35207          { (char *)"ToolBarBase_GetToolPacking", (PyCFunction) _wrap_ToolBarBase_GetToolPacking, METH_VARARGS | METH_KEYWORDS, NULL},
35208          { (char *)"ToolBarBase_GetToolSeparation", (PyCFunction) _wrap_ToolBarBase_GetToolSeparation, METH_VARARGS | METH_KEYWORDS, NULL},
35209          { (char *)"ToolBarBase_SetRows", (PyCFunction) _wrap_ToolBarBase_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
35210          { (char *)"ToolBarBase_SetMaxRowsCols", (PyCFunction) _wrap_ToolBarBase_SetMaxRowsCols, METH_VARARGS | METH_KEYWORDS, NULL},
35211          { (char *)"ToolBarBase_GetMaxRows", (PyCFunction) _wrap_ToolBarBase_GetMaxRows, METH_VARARGS | METH_KEYWORDS, NULL},
35212          { (char *)"ToolBarBase_GetMaxCols", (PyCFunction) _wrap_ToolBarBase_GetMaxCols, METH_VARARGS | METH_KEYWORDS, NULL},
35213          { (char *)"ToolBarBase_SetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_SetToolBitmapSize, METH_VARARGS | METH_KEYWORDS, NULL},
35214          { (char *)"ToolBarBase_GetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_GetToolBitmapSize, METH_VARARGS | METH_KEYWORDS, NULL},
35215          { (char *)"ToolBarBase_GetToolSize", (PyCFunction) _wrap_ToolBarBase_GetToolSize, METH_VARARGS | METH_KEYWORDS, NULL},
35216          { (char *)"ToolBarBase_FindToolForPosition", (PyCFunction) _wrap_ToolBarBase_FindToolForPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35217          { (char *)"ToolBarBase_FindById", (PyCFunction) _wrap_ToolBarBase_FindById, METH_VARARGS | METH_KEYWORDS, NULL},
35218          { (char *)"ToolBarBase_IsVertical", (PyCFunction) _wrap_ToolBarBase_IsVertical, METH_VARARGS | METH_KEYWORDS, NULL},
35219          { (char *)"ToolBarBase_swigregister", ToolBarBase_swigregister, METH_VARARGS, NULL},
35220          { (char *)"new_ToolBar", (PyCFunction) _wrap_new_ToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35221          { (char *)"new_PreToolBar", (PyCFunction) _wrap_new_PreToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
35222          { (char *)"ToolBar_Create", (PyCFunction) _wrap_ToolBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35223          { (char *)"ToolBar_FindToolForPosition", (PyCFunction) _wrap_ToolBar_FindToolForPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35224          { (char *)"ToolBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ToolBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35225          { (char *)"ToolBar_swigregister", ToolBar_swigregister, METH_VARARGS, NULL},
35226          { (char *)"new_ListItemAttr", (PyCFunction) _wrap_new_ListItemAttr, METH_VARARGS | METH_KEYWORDS, NULL},
35227          { (char *)"ListItemAttr_SetTextColour", (PyCFunction) _wrap_ListItemAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35228          { (char *)"ListItemAttr_SetBackgroundColour", (PyCFunction) _wrap_ListItemAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35229          { (char *)"ListItemAttr_SetFont", (PyCFunction) _wrap_ListItemAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35230          { (char *)"ListItemAttr_HasTextColour", (PyCFunction) _wrap_ListItemAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35231          { (char *)"ListItemAttr_HasBackgroundColour", (PyCFunction) _wrap_ListItemAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35232          { (char *)"ListItemAttr_HasFont", (PyCFunction) _wrap_ListItemAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
35233          { (char *)"ListItemAttr_GetTextColour", (PyCFunction) _wrap_ListItemAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35234          { (char *)"ListItemAttr_GetBackgroundColour", (PyCFunction) _wrap_ListItemAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35235          { (char *)"ListItemAttr_GetFont", (PyCFunction) _wrap_ListItemAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35236          { (char *)"ListItemAttr_Destroy", (PyCFunction) _wrap_ListItemAttr_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35237          { (char *)"ListItemAttr_swigregister", ListItemAttr_swigregister, METH_VARARGS, NULL},
35238          { (char *)"new_ListItem", (PyCFunction) _wrap_new_ListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35239          { (char *)"delete_ListItem", (PyCFunction) _wrap_delete_ListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35240          { (char *)"ListItem_Clear", (PyCFunction) _wrap_ListItem_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
35241          { (char *)"ListItem_ClearAttributes", (PyCFunction) _wrap_ListItem_ClearAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35242          { (char *)"ListItem_SetMask", (PyCFunction) _wrap_ListItem_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35243          { (char *)"ListItem_SetId", (PyCFunction) _wrap_ListItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
35244          { (char *)"ListItem_SetColumn", (PyCFunction) _wrap_ListItem_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35245          { (char *)"ListItem_SetState", (PyCFunction) _wrap_ListItem_SetState, METH_VARARGS | METH_KEYWORDS, NULL},
35246          { (char *)"ListItem_SetStateMask", (PyCFunction) _wrap_ListItem_SetStateMask, METH_VARARGS | METH_KEYWORDS, NULL},
35247          { (char *)"ListItem_SetText", (PyCFunction) _wrap_ListItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
35248          { (char *)"ListItem_SetImage", (PyCFunction) _wrap_ListItem_SetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35249          { (char *)"ListItem_SetData", (PyCFunction) _wrap_ListItem_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
35250          { (char *)"ListItem_SetWidth", (PyCFunction) _wrap_ListItem_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35251          { (char *)"ListItem_SetAlign", (PyCFunction) _wrap_ListItem_SetAlign, METH_VARARGS | METH_KEYWORDS, NULL},
35252          { (char *)"ListItem_SetTextColour", (PyCFunction) _wrap_ListItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35253          { (char *)"ListItem_SetBackgroundColour", (PyCFunction) _wrap_ListItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35254          { (char *)"ListItem_SetFont", (PyCFunction) _wrap_ListItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35255          { (char *)"ListItem_GetMask", (PyCFunction) _wrap_ListItem_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35256          { (char *)"ListItem_GetId", (PyCFunction) _wrap_ListItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35257          { (char *)"ListItem_GetColumn", (PyCFunction) _wrap_ListItem_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35258          { (char *)"ListItem_GetState", (PyCFunction) _wrap_ListItem_GetState, METH_VARARGS | METH_KEYWORDS, NULL},
35259          { (char *)"ListItem_GetText", (PyCFunction) _wrap_ListItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
35260          { (char *)"ListItem_GetImage", (PyCFunction) _wrap_ListItem_GetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35261          { (char *)"ListItem_GetData", (PyCFunction) _wrap_ListItem_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35262          { (char *)"ListItem_GetWidth", (PyCFunction) _wrap_ListItem_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35263          { (char *)"ListItem_GetAlign", (PyCFunction) _wrap_ListItem_GetAlign, METH_VARARGS | METH_KEYWORDS, NULL},
35264          { (char *)"ListItem_GetAttributes", (PyCFunction) _wrap_ListItem_GetAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35265          { (char *)"ListItem_HasAttributes", (PyCFunction) _wrap_ListItem_HasAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35266          { (char *)"ListItem_GetTextColour", (PyCFunction) _wrap_ListItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35267          { (char *)"ListItem_GetBackgroundColour", (PyCFunction) _wrap_ListItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35268          { (char *)"ListItem_GetFont", (PyCFunction) _wrap_ListItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35269          { (char *)"ListItem_m_mask_set", (PyCFunction) _wrap_ListItem_m_mask_set, METH_VARARGS | METH_KEYWORDS, NULL},
35270          { (char *)"ListItem_m_mask_get", (PyCFunction) _wrap_ListItem_m_mask_get, METH_VARARGS | METH_KEYWORDS, NULL},
35271          { (char *)"ListItem_m_itemId_set", (PyCFunction) _wrap_ListItem_m_itemId_set, METH_VARARGS | METH_KEYWORDS, NULL},
35272          { (char *)"ListItem_m_itemId_get", (PyCFunction) _wrap_ListItem_m_itemId_get, METH_VARARGS | METH_KEYWORDS, NULL},
35273          { (char *)"ListItem_m_col_set", (PyCFunction) _wrap_ListItem_m_col_set, METH_VARARGS | METH_KEYWORDS, NULL},
35274          { (char *)"ListItem_m_col_get", (PyCFunction) _wrap_ListItem_m_col_get, METH_VARARGS | METH_KEYWORDS, NULL},
35275          { (char *)"ListItem_m_state_set", (PyCFunction) _wrap_ListItem_m_state_set, METH_VARARGS | METH_KEYWORDS, NULL},
35276          { (char *)"ListItem_m_state_get", (PyCFunction) _wrap_ListItem_m_state_get, METH_VARARGS | METH_KEYWORDS, NULL},
35277          { (char *)"ListItem_m_stateMask_set", (PyCFunction) _wrap_ListItem_m_stateMask_set, METH_VARARGS | METH_KEYWORDS, NULL},
35278          { (char *)"ListItem_m_stateMask_get", (PyCFunction) _wrap_ListItem_m_stateMask_get, METH_VARARGS | METH_KEYWORDS, NULL},
35279          { (char *)"ListItem_m_text_set", (PyCFunction) _wrap_ListItem_m_text_set, METH_VARARGS | METH_KEYWORDS, NULL},
35280          { (char *)"ListItem_m_text_get", (PyCFunction) _wrap_ListItem_m_text_get, METH_VARARGS | METH_KEYWORDS, NULL},
35281          { (char *)"ListItem_m_image_set", (PyCFunction) _wrap_ListItem_m_image_set, METH_VARARGS | METH_KEYWORDS, NULL},
35282          { (char *)"ListItem_m_image_get", (PyCFunction) _wrap_ListItem_m_image_get, METH_VARARGS | METH_KEYWORDS, NULL},
35283          { (char *)"ListItem_m_data_set", (PyCFunction) _wrap_ListItem_m_data_set, METH_VARARGS | METH_KEYWORDS, NULL},
35284          { (char *)"ListItem_m_data_get", (PyCFunction) _wrap_ListItem_m_data_get, METH_VARARGS | METH_KEYWORDS, NULL},
35285          { (char *)"ListItem_m_format_set", (PyCFunction) _wrap_ListItem_m_format_set, METH_VARARGS | METH_KEYWORDS, NULL},
35286          { (char *)"ListItem_m_format_get", (PyCFunction) _wrap_ListItem_m_format_get, METH_VARARGS | METH_KEYWORDS, NULL},
35287          { (char *)"ListItem_m_width_set", (PyCFunction) _wrap_ListItem_m_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
35288          { (char *)"ListItem_m_width_get", (PyCFunction) _wrap_ListItem_m_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
35289          { (char *)"ListItem_swigregister", ListItem_swigregister, METH_VARARGS, NULL},
35290          { (char *)"new_ListEvent", (PyCFunction) _wrap_new_ListEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35291          { (char *)"ListEvent_m_code_set", (PyCFunction) _wrap_ListEvent_m_code_set, METH_VARARGS | METH_KEYWORDS, NULL},
35292          { (char *)"ListEvent_m_code_get", (PyCFunction) _wrap_ListEvent_m_code_get, METH_VARARGS | METH_KEYWORDS, NULL},
35293          { (char *)"ListEvent_m_oldItemIndex_set", (PyCFunction) _wrap_ListEvent_m_oldItemIndex_set, METH_VARARGS | METH_KEYWORDS, NULL},
35294          { (char *)"ListEvent_m_oldItemIndex_get", (PyCFunction) _wrap_ListEvent_m_oldItemIndex_get, METH_VARARGS | METH_KEYWORDS, NULL},
35295          { (char *)"ListEvent_m_itemIndex_set", (PyCFunction) _wrap_ListEvent_m_itemIndex_set, METH_VARARGS | METH_KEYWORDS, NULL},
35296          { (char *)"ListEvent_m_itemIndex_get", (PyCFunction) _wrap_ListEvent_m_itemIndex_get, METH_VARARGS | METH_KEYWORDS, NULL},
35297          { (char *)"ListEvent_m_col_set", (PyCFunction) _wrap_ListEvent_m_col_set, METH_VARARGS | METH_KEYWORDS, NULL},
35298          { (char *)"ListEvent_m_col_get", (PyCFunction) _wrap_ListEvent_m_col_get, METH_VARARGS | METH_KEYWORDS, NULL},
35299          { (char *)"ListEvent_m_pointDrag_set", (PyCFunction) _wrap_ListEvent_m_pointDrag_set, METH_VARARGS | METH_KEYWORDS, NULL},
35300          { (char *)"ListEvent_m_pointDrag_get", (PyCFunction) _wrap_ListEvent_m_pointDrag_get, METH_VARARGS | METH_KEYWORDS, NULL},
35301          { (char *)"ListEvent_m_item_get", (PyCFunction) _wrap_ListEvent_m_item_get, METH_VARARGS | METH_KEYWORDS, NULL},
35302          { (char *)"ListEvent_GetKeyCode", (PyCFunction) _wrap_ListEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
35303          { (char *)"ListEvent_GetIndex", (PyCFunction) _wrap_ListEvent_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35304          { (char *)"ListEvent_GetColumn", (PyCFunction) _wrap_ListEvent_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35305          { (char *)"ListEvent_GetPoint", (PyCFunction) _wrap_ListEvent_GetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35306          { (char *)"ListEvent_GetLabel", (PyCFunction) _wrap_ListEvent_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35307          { (char *)"ListEvent_GetText", (PyCFunction) _wrap_ListEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
35308          { (char *)"ListEvent_GetImage", (PyCFunction) _wrap_ListEvent_GetImage, METH_VARARGS | METH_KEYWORDS, NULL},
35309          { (char *)"ListEvent_GetData", (PyCFunction) _wrap_ListEvent_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35310          { (char *)"ListEvent_GetMask", (PyCFunction) _wrap_ListEvent_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
35311          { (char *)"ListEvent_GetItem", (PyCFunction) _wrap_ListEvent_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35312          { (char *)"ListEvent_GetCacheFrom", (PyCFunction) _wrap_ListEvent_GetCacheFrom, METH_VARARGS | METH_KEYWORDS, NULL},
35313          { (char *)"ListEvent_GetCacheTo", (PyCFunction) _wrap_ListEvent_GetCacheTo, METH_VARARGS | METH_KEYWORDS, NULL},
35314          { (char *)"ListEvent_IsEditCancelled", (PyCFunction) _wrap_ListEvent_IsEditCancelled, METH_VARARGS | METH_KEYWORDS, NULL},
35315          { (char *)"ListEvent_SetEditCanceled", (PyCFunction) _wrap_ListEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
35316          { (char *)"ListEvent_swigregister", ListEvent_swigregister, METH_VARARGS, NULL},
35317          { (char *)"new_ListCtrl", (PyCFunction) _wrap_new_ListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35318          { (char *)"new_PreListCtrl", (PyCFunction) _wrap_new_PreListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35319          { (char *)"ListCtrl_Create", (PyCFunction) _wrap_ListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35320          { (char *)"ListCtrl__setCallbackInfo", (PyCFunction) _wrap_ListCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35321          { (char *)"ListCtrl_SetForegroundColour", (PyCFunction) _wrap_ListCtrl_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35322          { (char *)"ListCtrl_SetBackgroundColour", (PyCFunction) _wrap_ListCtrl_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35323          { (char *)"ListCtrl_GetColumn", (PyCFunction) _wrap_ListCtrl_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35324          { (char *)"ListCtrl_SetColumn", (PyCFunction) _wrap_ListCtrl_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35325          { (char *)"ListCtrl_GetColumnWidth", (PyCFunction) _wrap_ListCtrl_GetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35326          { (char *)"ListCtrl_SetColumnWidth", (PyCFunction) _wrap_ListCtrl_SetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
35327          { (char *)"ListCtrl_GetCountPerPage", (PyCFunction) _wrap_ListCtrl_GetCountPerPage, METH_VARARGS | METH_KEYWORDS, NULL},
35328          { (char *)"ListCtrl_GetViewRect", (PyCFunction) _wrap_ListCtrl_GetViewRect, METH_VARARGS | METH_KEYWORDS, NULL},
35329          { (char *)"ListCtrl_GetEditControl", (PyCFunction) _wrap_ListCtrl_GetEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
35330          { (char *)"ListCtrl_GetItem", (PyCFunction) _wrap_ListCtrl_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35331          { (char *)"ListCtrl_SetItem", (PyCFunction) _wrap_ListCtrl_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35332          { (char *)"ListCtrl_SetStringItem", (PyCFunction) _wrap_ListCtrl_SetStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35333          { (char *)"ListCtrl_GetItemState", (PyCFunction) _wrap_ListCtrl_GetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
35334          { (char *)"ListCtrl_SetItemState", (PyCFunction) _wrap_ListCtrl_SetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
35335          { (char *)"ListCtrl_SetItemImage", (PyCFunction) _wrap_ListCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35336          { (char *)"ListCtrl_GetItemText", (PyCFunction) _wrap_ListCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35337          { (char *)"ListCtrl_SetItemText", (PyCFunction) _wrap_ListCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35338          { (char *)"ListCtrl_GetItemData", (PyCFunction) _wrap_ListCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35339          { (char *)"ListCtrl_SetItemData", (PyCFunction) _wrap_ListCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35340          { (char *)"ListCtrl_GetItemPosition", (PyCFunction) _wrap_ListCtrl_GetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35341          { (char *)"ListCtrl_GetItemRect", (PyCFunction) _wrap_ListCtrl_GetItemRect, METH_VARARGS | METH_KEYWORDS, NULL},
35342          { (char *)"ListCtrl_SetItemPosition", (PyCFunction) _wrap_ListCtrl_SetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35343          { (char *)"ListCtrl_GetItemCount", (PyCFunction) _wrap_ListCtrl_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35344          { (char *)"ListCtrl_GetColumnCount", (PyCFunction) _wrap_ListCtrl_GetColumnCount, METH_VARARGS | METH_KEYWORDS, NULL},
35345          { (char *)"ListCtrl_GetItemSpacing", (PyCFunction) _wrap_ListCtrl_GetItemSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35346          { (char *)"ListCtrl_GetSelectedItemCount", (PyCFunction) _wrap_ListCtrl_GetSelectedItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35347          { (char *)"ListCtrl_GetTextColour", (PyCFunction) _wrap_ListCtrl_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35348          { (char *)"ListCtrl_SetTextColour", (PyCFunction) _wrap_ListCtrl_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35349          { (char *)"ListCtrl_GetTopItem", (PyCFunction) _wrap_ListCtrl_GetTopItem, METH_VARARGS | METH_KEYWORDS, NULL},
35350          { (char *)"ListCtrl_SetSingleStyle", (PyCFunction) _wrap_ListCtrl_SetSingleStyle, METH_VARARGS | METH_KEYWORDS, NULL},
35351          { (char *)"ListCtrl_SetWindowStyleFlag", (PyCFunction) _wrap_ListCtrl_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
35352          { (char *)"ListCtrl_GetNextItem", (PyCFunction) _wrap_ListCtrl_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
35353          { (char *)"ListCtrl_GetImageList", (PyCFunction) _wrap_ListCtrl_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35354          { (char *)"ListCtrl_SetImageList", (PyCFunction) _wrap_ListCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35355          { (char *)"ListCtrl_AssignImageList", (PyCFunction) _wrap_ListCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35356          { (char *)"ListCtrl_InReportView", (PyCFunction) _wrap_ListCtrl_InReportView, METH_VARARGS | METH_KEYWORDS, NULL},
35357          { (char *)"ListCtrl_IsVirtual", (PyCFunction) _wrap_ListCtrl_IsVirtual, METH_VARARGS | METH_KEYWORDS, NULL},
35358          { (char *)"ListCtrl_RefreshItem", (PyCFunction) _wrap_ListCtrl_RefreshItem, METH_VARARGS | METH_KEYWORDS, NULL},
35359          { (char *)"ListCtrl_RefreshItems", (PyCFunction) _wrap_ListCtrl_RefreshItems, METH_VARARGS | METH_KEYWORDS, NULL},
35360          { (char *)"ListCtrl_Arrange", (PyCFunction) _wrap_ListCtrl_Arrange, METH_VARARGS | METH_KEYWORDS, NULL},
35361          { (char *)"ListCtrl_DeleteItem", (PyCFunction) _wrap_ListCtrl_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
35362          { (char *)"ListCtrl_DeleteAllItems", (PyCFunction) _wrap_ListCtrl_DeleteAllItems, METH_VARARGS | METH_KEYWORDS, NULL},
35363          { (char *)"ListCtrl_DeleteColumn", (PyCFunction) _wrap_ListCtrl_DeleteColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35364          { (char *)"ListCtrl_DeleteAllColumns", (PyCFunction) _wrap_ListCtrl_DeleteAllColumns, METH_VARARGS | METH_KEYWORDS, NULL},
35365          { (char *)"ListCtrl_ClearAll", (PyCFunction) _wrap_ListCtrl_ClearAll, METH_VARARGS | METH_KEYWORDS, NULL},
35366          { (char *)"ListCtrl_EditLabel", (PyCFunction) _wrap_ListCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35367          { (char *)"ListCtrl_EndEditLabel", (PyCFunction) _wrap_ListCtrl_EndEditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35368          { (char *)"ListCtrl_EnsureVisible", (PyCFunction) _wrap_ListCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35369          { (char *)"ListCtrl_FindItem", (PyCFunction) _wrap_ListCtrl_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
35370          { (char *)"ListCtrl_FindItemData", (PyCFunction) _wrap_ListCtrl_FindItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35371          { (char *)"ListCtrl_FindItemAtPos", (PyCFunction) _wrap_ListCtrl_FindItemAtPos, METH_VARARGS | METH_KEYWORDS, NULL},
35372          { (char *)"ListCtrl_HitTest", (PyCFunction) _wrap_ListCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35373          { (char *)"ListCtrl_InsertItem", (PyCFunction) _wrap_ListCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
35374          { (char *)"ListCtrl_InsertStringItem", (PyCFunction) _wrap_ListCtrl_InsertStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35375          { (char *)"ListCtrl_InsertImageItem", (PyCFunction) _wrap_ListCtrl_InsertImageItem, METH_VARARGS | METH_KEYWORDS, NULL},
35376          { (char *)"ListCtrl_InsertImageStringItem", (PyCFunction) _wrap_ListCtrl_InsertImageStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
35377          { (char *)"ListCtrl_InsertColumnInfo", (PyCFunction) _wrap_ListCtrl_InsertColumnInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35378          { (char *)"ListCtrl_InsertColumn", (PyCFunction) _wrap_ListCtrl_InsertColumn, METH_VARARGS | METH_KEYWORDS, NULL},
35379          { (char *)"ListCtrl_SetItemCount", (PyCFunction) _wrap_ListCtrl_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
35380          { (char *)"ListCtrl_ScrollList", (PyCFunction) _wrap_ListCtrl_ScrollList, METH_VARARGS | METH_KEYWORDS, NULL},
35381          { (char *)"ListCtrl_SetItemTextColour", (PyCFunction) _wrap_ListCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35382          { (char *)"ListCtrl_GetItemTextColour", (PyCFunction) _wrap_ListCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35383          { (char *)"ListCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35384          { (char *)"ListCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35385          { (char *)"ListCtrl_SortItems", (PyCFunction) _wrap_ListCtrl_SortItems, METH_VARARGS | METH_KEYWORDS, NULL},
35386          { (char *)"ListCtrl_GetMainWindow", (PyCFunction) _wrap_ListCtrl_GetMainWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35387          { (char *)"ListCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_ListCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35388          { (char *)"ListCtrl_swigregister", ListCtrl_swigregister, METH_VARARGS, NULL},
35389          { (char *)"new_ListView", (PyCFunction) _wrap_new_ListView, METH_VARARGS | METH_KEYWORDS, NULL},
35390          { (char *)"new_PreListView", (PyCFunction) _wrap_new_PreListView, METH_VARARGS | METH_KEYWORDS, NULL},
35391          { (char *)"ListView_Create", (PyCFunction) _wrap_ListView_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35392          { (char *)"ListView_Select", (PyCFunction) _wrap_ListView_Select, METH_VARARGS | METH_KEYWORDS, NULL},
35393          { (char *)"ListView_Focus", (PyCFunction) _wrap_ListView_Focus, METH_VARARGS | METH_KEYWORDS, NULL},
35394          { (char *)"ListView_GetFocusedItem", (PyCFunction) _wrap_ListView_GetFocusedItem, METH_VARARGS | METH_KEYWORDS, NULL},
35395          { (char *)"ListView_GetNextSelected", (PyCFunction) _wrap_ListView_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35396          { (char *)"ListView_GetFirstSelected", (PyCFunction) _wrap_ListView_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35397          { (char *)"ListView_IsSelected", (PyCFunction) _wrap_ListView_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35398          { (char *)"ListView_SetColumnImage", (PyCFunction) _wrap_ListView_SetColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
35399          { (char *)"ListView_ClearColumnImage", (PyCFunction) _wrap_ListView_ClearColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
35400          { (char *)"ListView_swigregister", ListView_swigregister, METH_VARARGS, NULL},
35401          { (char *)"new_TreeItemId", (PyCFunction) _wrap_new_TreeItemId, METH_VARARGS | METH_KEYWORDS, NULL},
35402          { (char *)"delete_TreeItemId", (PyCFunction) _wrap_delete_TreeItemId, METH_VARARGS | METH_KEYWORDS, NULL},
35403          { (char *)"TreeItemId_IsOk", (PyCFunction) _wrap_TreeItemId_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
35404          { (char *)"TreeItemId___eq__", (PyCFunction) _wrap_TreeItemId___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
35405          { (char *)"TreeItemId___ne__", (PyCFunction) _wrap_TreeItemId___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
35406          { (char *)"TreeItemId_m_pItem_set", (PyCFunction) _wrap_TreeItemId_m_pItem_set, METH_VARARGS | METH_KEYWORDS, NULL},
35407          { (char *)"TreeItemId_m_pItem_get", (PyCFunction) _wrap_TreeItemId_m_pItem_get, METH_VARARGS | METH_KEYWORDS, NULL},
35408          { (char *)"TreeItemId_swigregister", TreeItemId_swigregister, METH_VARARGS, NULL},
35409          { (char *)"new_TreeItemData", (PyCFunction) _wrap_new_TreeItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35410          { (char *)"TreeItemData_GetData", (PyCFunction) _wrap_TreeItemData_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
35411          { (char *)"TreeItemData_SetData", (PyCFunction) _wrap_TreeItemData_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
35412          { (char *)"TreeItemData_GetId", (PyCFunction) _wrap_TreeItemData_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
35413          { (char *)"TreeItemData_SetId", (PyCFunction) _wrap_TreeItemData_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
35414          { (char *)"TreeItemData_Destroy", (PyCFunction) _wrap_TreeItemData_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35415          { (char *)"TreeItemData_swigregister", TreeItemData_swigregister, METH_VARARGS, NULL},
35416          { (char *)"new_TreeEvent", (PyCFunction) _wrap_new_TreeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35417          { (char *)"TreeEvent_GetItem", (PyCFunction) _wrap_TreeEvent_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35418          { (char *)"TreeEvent_SetItem", (PyCFunction) _wrap_TreeEvent_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
35419          { (char *)"TreeEvent_GetOldItem", (PyCFunction) _wrap_TreeEvent_GetOldItem, METH_VARARGS | METH_KEYWORDS, NULL},
35420          { (char *)"TreeEvent_SetOldItem", (PyCFunction) _wrap_TreeEvent_SetOldItem, METH_VARARGS | METH_KEYWORDS, NULL},
35421          { (char *)"TreeEvent_GetPoint", (PyCFunction) _wrap_TreeEvent_GetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35422          { (char *)"TreeEvent_SetPoint", (PyCFunction) _wrap_TreeEvent_SetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35423          { (char *)"TreeEvent_GetKeyEvent", (PyCFunction) _wrap_TreeEvent_GetKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35424          { (char *)"TreeEvent_GetKeyCode", (PyCFunction) _wrap_TreeEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
35425          { (char *)"TreeEvent_SetKeyEvent", (PyCFunction) _wrap_TreeEvent_SetKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35426          { (char *)"TreeEvent_GetLabel", (PyCFunction) _wrap_TreeEvent_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35427          { (char *)"TreeEvent_SetLabel", (PyCFunction) _wrap_TreeEvent_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35428          { (char *)"TreeEvent_IsEditCancelled", (PyCFunction) _wrap_TreeEvent_IsEditCancelled, METH_VARARGS | METH_KEYWORDS, NULL},
35429          { (char *)"TreeEvent_SetEditCanceled", (PyCFunction) _wrap_TreeEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
35430          { (char *)"TreeEvent_SetToolTip", (PyCFunction) _wrap_TreeEvent_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35431          { (char *)"TreeEvent_swigregister", TreeEvent_swigregister, METH_VARARGS, NULL},
35432          { (char *)"new_TreeCtrl", (PyCFunction) _wrap_new_TreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35433          { (char *)"new_PreTreeCtrl", (PyCFunction) _wrap_new_PreTreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35434          { (char *)"TreeCtrl_Create", (PyCFunction) _wrap_TreeCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35435          { (char *)"TreeCtrl__setCallbackInfo", (PyCFunction) _wrap_TreeCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35436          { (char *)"TreeCtrl_GetCount", (PyCFunction) _wrap_TreeCtrl_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
35437          { (char *)"TreeCtrl_GetIndent", (PyCFunction) _wrap_TreeCtrl_GetIndent, METH_VARARGS | METH_KEYWORDS, NULL},
35438          { (char *)"TreeCtrl_SetIndent", (PyCFunction) _wrap_TreeCtrl_SetIndent, METH_VARARGS | METH_KEYWORDS, NULL},
35439          { (char *)"TreeCtrl_GetSpacing", (PyCFunction) _wrap_TreeCtrl_GetSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35440          { (char *)"TreeCtrl_SetSpacing", (PyCFunction) _wrap_TreeCtrl_SetSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
35441          { (char *)"TreeCtrl_GetImageList", (PyCFunction) _wrap_TreeCtrl_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35442          { (char *)"TreeCtrl_GetStateImageList", (PyCFunction) _wrap_TreeCtrl_GetStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35443          { (char *)"TreeCtrl_SetImageList", (PyCFunction) _wrap_TreeCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35444          { (char *)"TreeCtrl_SetStateImageList", (PyCFunction) _wrap_TreeCtrl_SetStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35445          { (char *)"TreeCtrl_AssignImageList", (PyCFunction) _wrap_TreeCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35446          { (char *)"TreeCtrl_AssignStateImageList", (PyCFunction) _wrap_TreeCtrl_AssignStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
35447          { (char *)"TreeCtrl_GetItemText", (PyCFunction) _wrap_TreeCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35448          { (char *)"TreeCtrl_GetItemImage", (PyCFunction) _wrap_TreeCtrl_GetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35449          { (char *)"TreeCtrl_GetItemData", (PyCFunction) _wrap_TreeCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35450          { (char *)"TreeCtrl_GetItemPyData", (PyCFunction) _wrap_TreeCtrl_GetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
35451          { (char *)"TreeCtrl_GetItemTextColour", (PyCFunction) _wrap_TreeCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35452          { (char *)"TreeCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35453          { (char *)"TreeCtrl_GetItemFont", (PyCFunction) _wrap_TreeCtrl_GetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
35454          { (char *)"TreeCtrl_SetItemText", (PyCFunction) _wrap_TreeCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
35455          { (char *)"TreeCtrl_SetItemImage", (PyCFunction) _wrap_TreeCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
35456          { (char *)"TreeCtrl_SetItemData", (PyCFunction) _wrap_TreeCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
35457          { (char *)"TreeCtrl_SetItemPyData", (PyCFunction) _wrap_TreeCtrl_SetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
35458          { (char *)"TreeCtrl_SetItemHasChildren", (PyCFunction) _wrap_TreeCtrl_SetItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35459          { (char *)"TreeCtrl_SetItemBold", (PyCFunction) _wrap_TreeCtrl_SetItemBold, METH_VARARGS | METH_KEYWORDS, NULL},
35460          { (char *)"TreeCtrl_SetItemDropHighlight", (PyCFunction) _wrap_TreeCtrl_SetItemDropHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
35461          { (char *)"TreeCtrl_SetItemTextColour", (PyCFunction) _wrap_TreeCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
35462          { (char *)"TreeCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
35463          { (char *)"TreeCtrl_SetItemFont", (PyCFunction) _wrap_TreeCtrl_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
35464          { (char *)"TreeCtrl_IsVisible", (PyCFunction) _wrap_TreeCtrl_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35465          { (char *)"TreeCtrl_ItemHasChildren", (PyCFunction) _wrap_TreeCtrl_ItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35466          { (char *)"TreeCtrl_IsExpanded", (PyCFunction) _wrap_TreeCtrl_IsExpanded, METH_VARARGS | METH_KEYWORDS, NULL},
35467          { (char *)"TreeCtrl_IsSelected", (PyCFunction) _wrap_TreeCtrl_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
35468          { (char *)"TreeCtrl_IsBold", (PyCFunction) _wrap_TreeCtrl_IsBold, METH_VARARGS | METH_KEYWORDS, NULL},
35469          { (char *)"TreeCtrl_GetChildrenCount", (PyCFunction) _wrap_TreeCtrl_GetChildrenCount, METH_VARARGS | METH_KEYWORDS, NULL},
35470          { (char *)"TreeCtrl_GetRootItem", (PyCFunction) _wrap_TreeCtrl_GetRootItem, METH_VARARGS | METH_KEYWORDS, NULL},
35471          { (char *)"TreeCtrl_GetSelection", (PyCFunction) _wrap_TreeCtrl_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35472          { (char *)"TreeCtrl_GetSelections", (PyCFunction) _wrap_TreeCtrl_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
35473          { (char *)"TreeCtrl_GetItemParent", (PyCFunction) _wrap_TreeCtrl_GetItemParent, METH_VARARGS | METH_KEYWORDS, NULL},
35474          { (char *)"TreeCtrl_GetFirstChild", (PyCFunction) _wrap_TreeCtrl_GetFirstChild, METH_VARARGS | METH_KEYWORDS, NULL},
35475          { (char *)"TreeCtrl_GetNextChild", (PyCFunction) _wrap_TreeCtrl_GetNextChild, METH_VARARGS | METH_KEYWORDS, NULL},
35476          { (char *)"TreeCtrl_GetLastChild", (PyCFunction) _wrap_TreeCtrl_GetLastChild, METH_VARARGS | METH_KEYWORDS, NULL},
35477          { (char *)"TreeCtrl_GetNextSibling", (PyCFunction) _wrap_TreeCtrl_GetNextSibling, METH_VARARGS | METH_KEYWORDS, NULL},
35478          { (char *)"TreeCtrl_GetPrevSibling", (PyCFunction) _wrap_TreeCtrl_GetPrevSibling, METH_VARARGS | METH_KEYWORDS, NULL},
35479          { (char *)"TreeCtrl_GetFirstVisibleItem", (PyCFunction) _wrap_TreeCtrl_GetFirstVisibleItem, METH_VARARGS | METH_KEYWORDS, NULL},
35480          { (char *)"TreeCtrl_GetNextVisible", (PyCFunction) _wrap_TreeCtrl_GetNextVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35481          { (char *)"TreeCtrl_GetPrevVisible", (PyCFunction) _wrap_TreeCtrl_GetPrevVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35482          { (char *)"TreeCtrl_AddRoot", (PyCFunction) _wrap_TreeCtrl_AddRoot, METH_VARARGS | METH_KEYWORDS, NULL},
35483          { (char *)"TreeCtrl_PrependItem", (PyCFunction) _wrap_TreeCtrl_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
35484          { (char *)"TreeCtrl_InsertItem", (PyCFunction) _wrap_TreeCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
35485          { (char *)"TreeCtrl_InsertItemBefore", (PyCFunction) _wrap_TreeCtrl_InsertItemBefore, METH_VARARGS | METH_KEYWORDS, NULL},
35486          { (char *)"TreeCtrl_AppendItem", (PyCFunction) _wrap_TreeCtrl_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
35487          { (char *)"TreeCtrl_Delete", (PyCFunction) _wrap_TreeCtrl_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
35488          { (char *)"TreeCtrl_DeleteChildren", (PyCFunction) _wrap_TreeCtrl_DeleteChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35489          { (char *)"TreeCtrl_DeleteAllItems", (PyCFunction) _wrap_TreeCtrl_DeleteAllItems, METH_VARARGS | METH_KEYWORDS, NULL},
35490          { (char *)"TreeCtrl_Expand", (PyCFunction) _wrap_TreeCtrl_Expand, METH_VARARGS | METH_KEYWORDS, NULL},
35491          { (char *)"TreeCtrl_Collapse", (PyCFunction) _wrap_TreeCtrl_Collapse, METH_VARARGS | METH_KEYWORDS, NULL},
35492          { (char *)"TreeCtrl_CollapseAndReset", (PyCFunction) _wrap_TreeCtrl_CollapseAndReset, METH_VARARGS | METH_KEYWORDS, NULL},
35493          { (char *)"TreeCtrl_Toggle", (PyCFunction) _wrap_TreeCtrl_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
35494          { (char *)"TreeCtrl_Unselect", (PyCFunction) _wrap_TreeCtrl_Unselect, METH_VARARGS | METH_KEYWORDS, NULL},
35495          { (char *)"TreeCtrl_UnselectItem", (PyCFunction) _wrap_TreeCtrl_UnselectItem, METH_VARARGS | METH_KEYWORDS, NULL},
35496          { (char *)"TreeCtrl_UnselectAll", (PyCFunction) _wrap_TreeCtrl_UnselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
35497          { (char *)"TreeCtrl_SelectItem", (PyCFunction) _wrap_TreeCtrl_SelectItem, METH_VARARGS | METH_KEYWORDS, NULL},
35498          { (char *)"TreeCtrl_ToggleItemSelection", (PyCFunction) _wrap_TreeCtrl_ToggleItemSelection, METH_VARARGS | METH_KEYWORDS, NULL},
35499          { (char *)"TreeCtrl_EnsureVisible", (PyCFunction) _wrap_TreeCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
35500          { (char *)"TreeCtrl_ScrollTo", (PyCFunction) _wrap_TreeCtrl_ScrollTo, METH_VARARGS | METH_KEYWORDS, NULL},
35501          { (char *)"TreeCtrl_EditLabel", (PyCFunction) _wrap_TreeCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35502          { (char *)"TreeCtrl_GetEditControl", (PyCFunction) _wrap_TreeCtrl_GetEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
35503          { (char *)"TreeCtrl_EndEditLabel", (PyCFunction) _wrap_TreeCtrl_EndEditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35504          { (char *)"TreeCtrl_SortChildren", (PyCFunction) _wrap_TreeCtrl_SortChildren, METH_VARARGS | METH_KEYWORDS, NULL},
35505          { (char *)"TreeCtrl_HitTest", (PyCFunction) _wrap_TreeCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
35506          { (char *)"TreeCtrl_GetBoundingRect", (PyCFunction) _wrap_TreeCtrl_GetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
35507          { (char *)"TreeCtrl_SetState", (PyCFunction) _wrap_TreeCtrl_SetState, METH_VARARGS | METH_KEYWORDS, NULL},
35508          { (char *)"TreeCtrl_GetState", (PyCFunction) _wrap_TreeCtrl_GetState, METH_VARARGS | METH_KEYWORDS, NULL},
35509          { (char *)"TreeCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TreeCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35510          { (char *)"TreeCtrl_swigregister", TreeCtrl_swigregister, METH_VARARGS, NULL},
35511          { (char *)"new_GenericDirCtrl", (PyCFunction) _wrap_new_GenericDirCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35512          { (char *)"new_PreGenericDirCtrl", (PyCFunction) _wrap_new_PreGenericDirCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35513          { (char *)"GenericDirCtrl_Create", (PyCFunction) _wrap_GenericDirCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35514          { (char *)"GenericDirCtrl_ExpandPath", (PyCFunction) _wrap_GenericDirCtrl_ExpandPath, METH_VARARGS | METH_KEYWORDS, NULL},
35515          { (char *)"GenericDirCtrl_GetDefaultPath", (PyCFunction) _wrap_GenericDirCtrl_GetDefaultPath, METH_VARARGS | METH_KEYWORDS, NULL},
35516          { (char *)"GenericDirCtrl_SetDefaultPath", (PyCFunction) _wrap_GenericDirCtrl_SetDefaultPath, METH_VARARGS | METH_KEYWORDS, NULL},
35517          { (char *)"GenericDirCtrl_GetPath", (PyCFunction) _wrap_GenericDirCtrl_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
35518          { (char *)"GenericDirCtrl_GetFilePath", (PyCFunction) _wrap_GenericDirCtrl_GetFilePath, METH_VARARGS | METH_KEYWORDS, NULL},
35519          { (char *)"GenericDirCtrl_SetPath", (PyCFunction) _wrap_GenericDirCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
35520          { (char *)"GenericDirCtrl_ShowHidden", (PyCFunction) _wrap_GenericDirCtrl_ShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
35521          { (char *)"GenericDirCtrl_GetShowHidden", (PyCFunction) _wrap_GenericDirCtrl_GetShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
35522          { (char *)"GenericDirCtrl_GetFilter", (PyCFunction) _wrap_GenericDirCtrl_GetFilter, METH_VARARGS | METH_KEYWORDS, NULL},
35523          { (char *)"GenericDirCtrl_SetFilter", (PyCFunction) _wrap_GenericDirCtrl_SetFilter, METH_VARARGS | METH_KEYWORDS, NULL},
35524          { (char *)"GenericDirCtrl_GetFilterIndex", (PyCFunction) _wrap_GenericDirCtrl_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35525          { (char *)"GenericDirCtrl_SetFilterIndex", (PyCFunction) _wrap_GenericDirCtrl_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35526          { (char *)"GenericDirCtrl_GetRootId", (PyCFunction) _wrap_GenericDirCtrl_GetRootId, METH_VARARGS | METH_KEYWORDS, NULL},
35527          { (char *)"GenericDirCtrl_GetTreeCtrl", (PyCFunction) _wrap_GenericDirCtrl_GetTreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35528          { (char *)"GenericDirCtrl_GetFilterListCtrl", (PyCFunction) _wrap_GenericDirCtrl_GetFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35529          { (char *)"GenericDirCtrl_FindChild", (PyCFunction) _wrap_GenericDirCtrl_FindChild, METH_VARARGS | METH_KEYWORDS, NULL},
35530          { (char *)"GenericDirCtrl_DoResize", (PyCFunction) _wrap_GenericDirCtrl_DoResize, METH_VARARGS | METH_KEYWORDS, NULL},
35531          { (char *)"GenericDirCtrl_ReCreateTree", (PyCFunction) _wrap_GenericDirCtrl_ReCreateTree, METH_VARARGS | METH_KEYWORDS, NULL},
35532          { (char *)"GenericDirCtrl_swigregister", GenericDirCtrl_swigregister, METH_VARARGS, NULL},
35533          { (char *)"new_DirFilterListCtrl", (PyCFunction) _wrap_new_DirFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35534          { (char *)"new_PreDirFilterListCtrl", (PyCFunction) _wrap_new_PreDirFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
35535          { (char *)"DirFilterListCtrl_Create", (PyCFunction) _wrap_DirFilterListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35536          { (char *)"DirFilterListCtrl_FillFilterList", (PyCFunction) _wrap_DirFilterListCtrl_FillFilterList, METH_VARARGS | METH_KEYWORDS, NULL},
35537          { (char *)"DirFilterListCtrl_swigregister", DirFilterListCtrl_swigregister, METH_VARARGS, NULL},
35538          { (char *)"new_PyControl", (PyCFunction) _wrap_new_PyControl, METH_VARARGS | METH_KEYWORDS, NULL},
35539          { (char *)"new_PrePyControl", (PyCFunction) _wrap_new_PrePyControl, METH_VARARGS | METH_KEYWORDS, NULL},
35540          { (char *)"PyControl__setCallbackInfo", (PyCFunction) _wrap_PyControl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35541          { (char *)"PyControl_SetBestSize", (PyCFunction) _wrap_PyControl_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
35542          { (char *)"PyControl_base_DoMoveWindow", (PyCFunction) _wrap_PyControl_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35543          { (char *)"PyControl_base_DoSetSize", (PyCFunction) _wrap_PyControl_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35544          { (char *)"PyControl_base_DoSetClientSize", (PyCFunction) _wrap_PyControl_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
35545          { (char *)"PyControl_base_DoSetVirtualSize", (PyCFunction) _wrap_PyControl_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
35546          { (char *)"PyControl_base_DoGetSize", (PyCFunction) _wrap_PyControl_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35547          { (char *)"PyControl_base_DoGetClientSize", (PyCFunction) _wrap_PyControl_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
35548          { (char *)"PyControl_base_DoGetPosition", (PyCFunction) _wrap_PyControl_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35549          { (char *)"PyControl_base_DoGetVirtualSize", (PyCFunction) _wrap_PyControl_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
35550          { (char *)"PyControl_base_DoGetBestSize", (PyCFunction) _wrap_PyControl_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
35551          { (char *)"PyControl_base_InitDialog", (PyCFunction) _wrap_PyControl_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
35552          { (char *)"PyControl_base_TransferDataToWindow", (PyCFunction) _wrap_PyControl_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35553          { (char *)"PyControl_base_TransferDataFromWindow", (PyCFunction) _wrap_PyControl_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35554          { (char *)"PyControl_base_Validate", (PyCFunction) _wrap_PyControl_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
35555          { (char *)"PyControl_base_AcceptsFocus", (PyCFunction) _wrap_PyControl_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
35556          { (char *)"PyControl_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyControl_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
35557          { (char *)"PyControl_base_GetMaxSize", (PyCFunction) _wrap_PyControl_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
35558          { (char *)"PyControl_base_AddChild", (PyCFunction) _wrap_PyControl_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
35559          { (char *)"PyControl_base_RemoveChild", (PyCFunction) _wrap_PyControl_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
35560          { (char *)"PyControl_base_ShouldInheritColours", (PyCFunction) _wrap_PyControl_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
35561          { (char *)"PyControl_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyControl_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
35562          { (char *)"PyControl_base_GetDefaultAttributes", (PyCFunction) _wrap_PyControl_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
35563          { (char *)"PyControl_swigregister", PyControl_swigregister, METH_VARARGS, NULL},
35564          { (char *)"new_HelpEvent", (PyCFunction) _wrap_new_HelpEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35565          { (char *)"HelpEvent_GetPosition", (PyCFunction) _wrap_HelpEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35566          { (char *)"HelpEvent_SetPosition", (PyCFunction) _wrap_HelpEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
35567          { (char *)"HelpEvent_GetLink", (PyCFunction) _wrap_HelpEvent_GetLink, METH_VARARGS | METH_KEYWORDS, NULL},
35568          { (char *)"HelpEvent_SetLink", (PyCFunction) _wrap_HelpEvent_SetLink, METH_VARARGS | METH_KEYWORDS, NULL},
35569          { (char *)"HelpEvent_GetTarget", (PyCFunction) _wrap_HelpEvent_GetTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35570          { (char *)"HelpEvent_SetTarget", (PyCFunction) _wrap_HelpEvent_SetTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35571          { (char *)"HelpEvent_swigregister", HelpEvent_swigregister, METH_VARARGS, NULL},
35572          { (char *)"new_ContextHelp", (PyCFunction) _wrap_new_ContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35573          { (char *)"delete_ContextHelp", (PyCFunction) _wrap_delete_ContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35574          { (char *)"ContextHelp_BeginContextHelp", (PyCFunction) _wrap_ContextHelp_BeginContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35575          { (char *)"ContextHelp_EndContextHelp", (PyCFunction) _wrap_ContextHelp_EndContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35576          { (char *)"ContextHelp_swigregister", ContextHelp_swigregister, METH_VARARGS, NULL},
35577          { (char *)"new_ContextHelpButton", (PyCFunction) _wrap_new_ContextHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
35578          { (char *)"ContextHelpButton_swigregister", ContextHelpButton_swigregister, METH_VARARGS, NULL},
35579          { (char *)"HelpProvider_Set", (PyCFunction) _wrap_HelpProvider_Set, METH_VARARGS | METH_KEYWORDS, NULL},
35580          { (char *)"HelpProvider_Get", (PyCFunction) _wrap_HelpProvider_Get, METH_VARARGS | METH_KEYWORDS, NULL},
35581          { (char *)"HelpProvider_GetHelp", (PyCFunction) _wrap_HelpProvider_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35582          { (char *)"HelpProvider_ShowHelp", (PyCFunction) _wrap_HelpProvider_ShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35583          { (char *)"HelpProvider_AddHelp", (PyCFunction) _wrap_HelpProvider_AddHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35584          { (char *)"HelpProvider_AddHelpById", (PyCFunction) _wrap_HelpProvider_AddHelpById, METH_VARARGS | METH_KEYWORDS, NULL},
35585          { (char *)"HelpProvider_RemoveHelp", (PyCFunction) _wrap_HelpProvider_RemoveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
35586          { (char *)"HelpProvider_Destroy", (PyCFunction) _wrap_HelpProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
35587          { (char *)"HelpProvider_swigregister", HelpProvider_swigregister, METH_VARARGS, NULL},
35588          { (char *)"new_SimpleHelpProvider", (PyCFunction) _wrap_new_SimpleHelpProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35589          { (char *)"SimpleHelpProvider_swigregister", SimpleHelpProvider_swigregister, METH_VARARGS, NULL},
35590          { (char *)"new_DragImage", (PyCFunction) _wrap_new_DragImage, METH_VARARGS | METH_KEYWORDS, NULL},
35591          { (char *)"new_DragIcon", (PyCFunction) _wrap_new_DragIcon, METH_VARARGS | METH_KEYWORDS, NULL},
35592          { (char *)"new_DragString", (PyCFunction) _wrap_new_DragString, METH_VARARGS | METH_KEYWORDS, NULL},
35593          { (char *)"new_DragTreeItem", (PyCFunction) _wrap_new_DragTreeItem, METH_VARARGS | METH_KEYWORDS, NULL},
35594          { (char *)"new_DragListItem", (PyCFunction) _wrap_new_DragListItem, METH_VARARGS | METH_KEYWORDS, NULL},
35595          { (char *)"delete_DragImage", (PyCFunction) _wrap_delete_DragImage, METH_VARARGS | METH_KEYWORDS, NULL},
35596          { (char *)"DragImage_SetBackingBitmap", (PyCFunction) _wrap_DragImage_SetBackingBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
35597          { (char *)"DragImage_BeginDrag", (PyCFunction) _wrap_DragImage_BeginDrag, METH_VARARGS | METH_KEYWORDS, NULL},
35598          { (char *)"DragImage_BeginDragBounded", (PyCFunction) _wrap_DragImage_BeginDragBounded, METH_VARARGS | METH_KEYWORDS, NULL},
35599          { (char *)"DragImage_EndDrag", (PyCFunction) _wrap_DragImage_EndDrag, METH_VARARGS | METH_KEYWORDS, NULL},
35600          { (char *)"DragImage_Move", (PyCFunction) _wrap_DragImage_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35601          { (char *)"DragImage_Show", (PyCFunction) _wrap_DragImage_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35602          { (char *)"DragImage_Hide", (PyCFunction) _wrap_DragImage_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
35603          { (char *)"DragImage_GetImageRect", (PyCFunction) _wrap_DragImage_GetImageRect, METH_VARARGS | METH_KEYWORDS, NULL},
35604          { (char *)"DragImage_DoDrawImage", (PyCFunction) _wrap_DragImage_DoDrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
35605          { (char *)"DragImage_UpdateBackingFromWindow", (PyCFunction) _wrap_DragImage_UpdateBackingFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
35606          { (char *)"DragImage_RedrawImage", (PyCFunction) _wrap_DragImage_RedrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
35607          { (char *)"DragImage_swigregister", DragImage_swigregister, METH_VARARGS, NULL},
35608          { NULL, NULL, 0, NULL }
35609 };
35610
35611
35612 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
35613
35614 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
35615     return (void *)((wxSizer *)  ((wxBoxSizer *) x));
35616 }
35617 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
35618     return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
35619 }
35620 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
35621     return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
35622 }
35623 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
35624     return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
35625 }
35626 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
35627     return (void *)((wxSizer *)  ((wxGridSizer *) x));
35628 }
35629 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
35630     return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
35631 }
35632 static void *_p_wxNotebookSizerTo_p_wxSizer(void *x) {
35633     return (void *)((wxSizer *)  ((wxNotebookSizer *) x));
35634 }
35635 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
35636     return (void *)((wxSizer *)  ((wxPySizer *) x));
35637 }
35638 static void *_p_wxBookCtrlSizerTo_p_wxSizer(void *x) {
35639     return (void *)((wxSizer *)  ((wxBookCtrlSizer *) x));
35640 }
35641 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
35642     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
35643 }
35644 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
35645     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
35646 }
35647 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
35648     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
35649 }
35650 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
35651     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
35652 }
35653 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
35654     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
35655 }
35656 static void *_p_wxBookCtrlBaseEventTo_p_wxEvent(void *x) {
35657     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
35658 }
35659 static void *_p_wxTreeEventTo_p_wxEvent(void *x) {
35660     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
35661 }
35662 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
35663     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
35664 }
35665 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
35666     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
35667 }
35668 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
35669     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
35670 }
35671 static void *_p_wxTextUrlEventTo_p_wxEvent(void *x) {
35672     return (void *)((wxEvent *) (wxCommandEvent *) ((wxTextUrlEvent *) x));
35673 }
35674 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
35675     return (void *)((wxEvent *)  ((wxPyEvent *) x));
35676 }
35677 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
35678     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
35679 }
35680 static void *_p_wxListEventTo_p_wxEvent(void *x) {
35681     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
35682 }
35683 static void *_p_wxNotebookEventTo_p_wxEvent(void *x) {
35684     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
35685 }
35686 static void *_p_wxListbookEventTo_p_wxEvent(void *x) {
35687     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
35688 }
35689 static void *_p_wxChoicebookEventTo_p_wxEvent(void *x) {
35690     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
35691 }
35692 static void *_p_wxHelpEventTo_p_wxEvent(void *x) {
35693     return (void *)((wxEvent *) (wxCommandEvent *) ((wxHelpEvent *) x));
35694 }
35695 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
35696     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
35697 }
35698 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
35699     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
35700 }
35701 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
35702     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
35703 }
35704 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
35705     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
35706 }
35707 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
35708     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
35709 }
35710 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
35711     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
35712 }
35713 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
35714     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
35715 }
35716 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
35717     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
35718 }
35719 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
35720     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
35721 }
35722 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
35723     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
35724 }
35725 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
35726     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
35727 }
35728 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
35729     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
35730 }
35731 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
35732     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
35733 }
35734 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
35735     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
35736 }
35737 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
35738     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
35739 }
35740 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
35741     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
35742 }
35743 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
35744     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
35745 }
35746 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
35747     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
35748 }
35749 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
35750     return (void *)((wxEvent *)  ((wxShowEvent *) x));
35751 }
35752 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
35753     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
35754 }
35755 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
35756     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
35757 }
35758 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
35759     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
35760 }
35761 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
35762     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
35763 }
35764 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
35765     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
35766 }
35767 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
35768     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
35769 }
35770 static void *_p_wxSpinEventTo_p_wxEvent(void *x) {
35771     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
35772 }
35773 static void *_p_wxComboBoxTo_p_wxItemContainer(void *x) {
35774     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35775 }
35776 static void *_p_wxDirFilterListCtrlTo_p_wxItemContainer(void *x) {
35777     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35778 }
35779 static void *_p_wxChoiceTo_p_wxItemContainer(void *x) {
35780     return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxChoice *) x));
35781 }
35782 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
35783     return (void *)((wxItemContainer *)  ((wxControlWithItems *) x));
35784 }
35785 static void *_p_wxListBoxTo_p_wxItemContainer(void *x) {
35786     return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxListBox *) x));
35787 }
35788 static void *_p_wxCheckListBoxTo_p_wxItemContainer(void *x) {
35789     return (void *)((wxItemContainer *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
35790 }
35791 static void *_p_wxListViewTo_p_wxPyListCtrl(void *x) {
35792     return (void *)((wxPyListCtrl *)  ((wxListView *) x));
35793 }
35794 static void *_p_wxBookCtrlBaseTo_p_wxControl(void *x) {
35795     return (void *)((wxControl *)  ((wxBookCtrlBase *) x));
35796 }
35797 static void *_p_wxToolBarTo_p_wxControl(void *x) {
35798     return (void *)((wxControl *) (wxToolBarBase *) ((wxToolBar *) x));
35799 }
35800 static void *_p_wxToggleButtonTo_p_wxControl(void *x) {
35801     return (void *)((wxControl *)  ((wxToggleButton *) x));
35802 }
35803 static void *_p_wxRadioButtonTo_p_wxControl(void *x) {
35804     return (void *)((wxControl *)  ((wxRadioButton *) x));
35805 }
35806 static void *_p_wxPyControlTo_p_wxControl(void *x) {
35807     return (void *)((wxControl *)  ((wxPyControl *) x));
35808 }
35809 static void *_p_wxToolBarBaseTo_p_wxControl(void *x) {
35810     return (void *)((wxControl *)  ((wxToolBarBase *) x));
35811 }
35812 static void *_p_wxDirFilterListCtrlTo_p_wxControl(void *x) {
35813     return (void *)((wxControl *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35814 }
35815 static void *_p_wxPyListCtrlTo_p_wxControl(void *x) {
35816     return (void *)((wxControl *)  ((wxPyListCtrl *) x));
35817 }
35818 static void *_p_wxComboBoxTo_p_wxControl(void *x) {
35819     return (void *)((wxControl *) (wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35820 }
35821 static void *_p_wxGenericDirCtrlTo_p_wxControl(void *x) {
35822     return (void *)((wxControl *)  ((wxGenericDirCtrl *) x));
35823 }
35824 static void *_p_wxScrollBarTo_p_wxControl(void *x) {
35825     return (void *)((wxControl *)  ((wxScrollBar *) x));
35826 }
35827 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
35828     return (void *)((wxControl *)  ((wxControlWithItems *) x));
35829 }
35830 static void *_p_wxGaugeTo_p_wxControl(void *x) {
35831     return (void *)((wxControl *)  ((wxGauge *) x));
35832 }
35833 static void *_p_wxStaticLineTo_p_wxControl(void *x) {
35834     return (void *)((wxControl *)  ((wxStaticLine *) x));
35835 }
35836 static void *_p_wxChoicebookTo_p_wxControl(void *x) {
35837     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxChoicebook *) x));
35838 }
35839 static void *_p_wxListbookTo_p_wxControl(void *x) {
35840     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxListbook *) x));
35841 }
35842 static void *_p_wxPyTreeCtrlTo_p_wxControl(void *x) {
35843     return (void *)((wxControl *)  ((wxPyTreeCtrl *) x));
35844 }
35845 static void *_p_wxCheckBoxTo_p_wxControl(void *x) {
35846     return (void *)((wxControl *)  ((wxCheckBox *) x));
35847 }
35848 static void *_p_wxRadioBoxTo_p_wxControl(void *x) {
35849     return (void *)((wxControl *)  ((wxRadioBox *) x));
35850 }
35851 static void *_p_wxChoiceTo_p_wxControl(void *x) {
35852     return (void *)((wxControl *) (wxControlWithItems *) ((wxChoice *) x));
35853 }
35854 static void *_p_wxListBoxTo_p_wxControl(void *x) {
35855     return (void *)((wxControl *) (wxControlWithItems *) ((wxListBox *) x));
35856 }
35857 static void *_p_wxCheckListBoxTo_p_wxControl(void *x) {
35858     return (void *)((wxControl *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
35859 }
35860 static void *_p_wxListViewTo_p_wxControl(void *x) {
35861     return (void *)((wxControl *) (wxPyListCtrl *) ((wxListView *) x));
35862 }
35863 static void *_p_wxNotebookTo_p_wxControl(void *x) {
35864     return (void *)((wxControl *) (wxBookCtrlBase *) ((wxNotebook *) x));
35865 }
35866 static void *_p_wxStaticBitmapTo_p_wxControl(void *x) {
35867     return (void *)((wxControl *)  ((wxStaticBitmap *) x));
35868 }
35869 static void *_p_wxSpinCtrlTo_p_wxControl(void *x) {
35870     return (void *)((wxControl *)  ((wxSpinCtrl *) x));
35871 }
35872 static void *_p_wxStaticTextTo_p_wxControl(void *x) {
35873     return (void *)((wxControl *)  ((wxStaticText *) x));
35874 }
35875 static void *_p_wxStaticBoxTo_p_wxControl(void *x) {
35876     return (void *)((wxControl *)  ((wxStaticBox *) x));
35877 }
35878 static void *_p_wxSliderTo_p_wxControl(void *x) {
35879     return (void *)((wxControl *)  ((wxSlider *) x));
35880 }
35881 static void *_p_wxContextHelpButtonTo_p_wxControl(void *x) {
35882     return (void *)((wxControl *) (wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
35883 }
35884 static void *_p_wxSpinButtonTo_p_wxControl(void *x) {
35885     return (void *)((wxControl *)  ((wxSpinButton *) x));
35886 }
35887 static void *_p_wxButtonTo_p_wxControl(void *x) {
35888     return (void *)((wxControl *)  ((wxButton *) x));
35889 }
35890 static void *_p_wxBitmapButtonTo_p_wxControl(void *x) {
35891     return (void *)((wxControl *) (wxButton *) ((wxBitmapButton *) x));
35892 }
35893 static void *_p_wxTextCtrlTo_p_wxControl(void *x) {
35894     return (void *)((wxControl *)  ((wxTextCtrl *) x));
35895 }
35896 static void *_p_wxToolBarTo_p_wxToolBarBase(void *x) {
35897     return (void *)((wxToolBarBase *)  ((wxToolBar *) x));
35898 }
35899 static void *_p_wxComboBoxTo_p_wxChoice(void *x) {
35900     return (void *)((wxChoice *)  ((wxComboBox *) x));
35901 }
35902 static void *_p_wxDirFilterListCtrlTo_p_wxChoice(void *x) {
35903     return (void *)((wxChoice *)  ((wxDirFilterListCtrl *) x));
35904 }
35905 static void *_p_wxBookCtrlBaseEventTo_p_wxNotifyEvent(void *x) {
35906     return (void *)((wxNotifyEvent *)  ((wxBookCtrlBaseEvent *) x));
35907 }
35908 static void *_p_wxTreeEventTo_p_wxNotifyEvent(void *x) {
35909     return (void *)((wxNotifyEvent *)  ((wxTreeEvent *) x));
35910 }
35911 static void *_p_wxListEventTo_p_wxNotifyEvent(void *x) {
35912     return (void *)((wxNotifyEvent *)  ((wxListEvent *) x));
35913 }
35914 static void *_p_wxSpinEventTo_p_wxNotifyEvent(void *x) {
35915     return (void *)((wxNotifyEvent *)  ((wxSpinEvent *) x));
35916 }
35917 static void *_p_wxNotebookEventTo_p_wxNotifyEvent(void *x) {
35918     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
35919 }
35920 static void *_p_wxListbookEventTo_p_wxNotifyEvent(void *x) {
35921     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
35922 }
35923 static void *_p_wxChoicebookEventTo_p_wxNotifyEvent(void *x) {
35924     return (void *)((wxNotifyEvent *) (wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
35925 }
35926 static void *_p_wxChoicebookTo_p_wxBookCtrlBase(void *x) {
35927     return (void *)((wxBookCtrlBase *)  ((wxChoicebook *) x));
35928 }
35929 static void *_p_wxListbookTo_p_wxBookCtrlBase(void *x) {
35930     return (void *)((wxBookCtrlBase *)  ((wxListbook *) x));
35931 }
35932 static void *_p_wxNotebookTo_p_wxBookCtrlBase(void *x) {
35933     return (void *)((wxBookCtrlBase *)  ((wxNotebook *) x));
35934 }
35935 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
35936     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
35937 }
35938 static void *_p_wxBookCtrlBaseTo_p_wxEvtHandler(void *x) {
35939     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
35940 }
35941 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
35942     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
35943 }
35944 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
35945     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
35946 }
35947 static void *_p_wxToolBarTo_p_wxEvtHandler(void *x) {
35948     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
35949 }
35950 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
35951     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
35952 }
35953 static void *_p_wxToggleButtonTo_p_wxEvtHandler(void *x) {
35954     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxToggleButton *) x));
35955 }
35956 static void *_p_wxRadioButtonTo_p_wxEvtHandler(void *x) {
35957     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioButton *) x));
35958 }
35959 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
35960     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
35961 }
35962 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
35963     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
35964 }
35965 static void *_p_wxToolBarBaseTo_p_wxEvtHandler(void *x) {
35966     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxToolBarBase *) x));
35967 }
35968 static void *_p_wxComboBoxTo_p_wxEvtHandler(void *x) {
35969     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
35970 }
35971 static void *_p_wxPyListCtrlTo_p_wxEvtHandler(void *x) {
35972     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
35973 }
35974 static void *_p_wxDirFilterListCtrlTo_p_wxEvtHandler(void *x) {
35975     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
35976 }
35977 static void *_p_wxPyControlTo_p_wxEvtHandler(void *x) {
35978     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyControl *) x));
35979 }
35980 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
35981     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
35982 }
35983 static void *_p_wxGenericDirCtrlTo_p_wxEvtHandler(void *x) {
35984     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
35985 }
35986 static void *_p_wxScrollBarTo_p_wxEvtHandler(void *x) {
35987     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxScrollBar *) x));
35988 }
35989 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
35990     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
35991 }
35992 static void *_p_wxGaugeTo_p_wxEvtHandler(void *x) {
35993     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGauge *) x));
35994 }
35995 static void *_p_wxStaticLineTo_p_wxEvtHandler(void *x) {
35996     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticLine *) x));
35997 }
35998 static void *_p_wxChoicebookTo_p_wxEvtHandler(void *x) {
35999     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
36000 }
36001 static void *_p_wxListbookTo_p_wxEvtHandler(void *x) {
36002     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
36003 }
36004 static void *_p_wxPyTreeCtrlTo_p_wxEvtHandler(void *x) {
36005     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
36006 }
36007 static void *_p_wxCheckBoxTo_p_wxEvtHandler(void *x) {
36008     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxCheckBox *) x));
36009 }
36010 static void *_p_wxRadioBoxTo_p_wxEvtHandler(void *x) {
36011     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioBox *) x));
36012 }
36013 static void *_p_wxCheckListBoxTo_p_wxEvtHandler(void *x) {
36014     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
36015 }
36016 static void *_p_wxListBoxTo_p_wxEvtHandler(void *x) {
36017     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
36018 }
36019 static void *_p_wxChoiceTo_p_wxEvtHandler(void *x) {
36020     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
36021 }
36022 static void *_p_wxNotebookTo_p_wxEvtHandler(void *x) {
36023     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
36024 }
36025 static void *_p_wxStaticBitmapTo_p_wxEvtHandler(void *x) {
36026     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
36027 }
36028 static void *_p_wxListViewTo_p_wxEvtHandler(void *x) {
36029     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
36030 }
36031 static void *_p_wxSpinCtrlTo_p_wxEvtHandler(void *x) {
36032     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
36033 }
36034 static void *_p_wxStaticTextTo_p_wxEvtHandler(void *x) {
36035     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticText *) x));
36036 }
36037 static void *_p_wxStaticBoxTo_p_wxEvtHandler(void *x) {
36038     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBox *) x));
36039 }
36040 static void *_p_wxSliderTo_p_wxEvtHandler(void *x) {
36041     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSlider *) x));
36042 }
36043 static void *_p_wxSpinButtonTo_p_wxEvtHandler(void *x) {
36044     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinButton *) x));
36045 }
36046 static void *_p_wxButtonTo_p_wxEvtHandler(void *x) {
36047     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxButton *) x));
36048 }
36049 static void *_p_wxBitmapButtonTo_p_wxEvtHandler(void *x) {
36050     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxButton *) ((wxBitmapButton *) x));
36051 }
36052 static void *_p_wxContextHelpButtonTo_p_wxEvtHandler(void *x) {
36053     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36054 }
36055 static void *_p_wxTextCtrlTo_p_wxEvtHandler(void *x) {
36056     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxTextCtrl *) x));
36057 }
36058 static void *_p_wxCheckListBoxTo_p_wxListBox(void *x) {
36059     return (void *)((wxListBox *)  ((wxCheckListBox *) x));
36060 }
36061 static void *_p_wxBitmapButtonTo_p_wxButton(void *x) {
36062     return (void *)((wxButton *)  ((wxBitmapButton *) x));
36063 }
36064 static void *_p_wxContextHelpButtonTo_p_wxButton(void *x) {
36065     return (void *)((wxButton *) (wxBitmapButton *) ((wxContextHelpButton *) x));
36066 }
36067 static void *_p_wxContextHelpButtonTo_p_wxBitmapButton(void *x) {
36068     return (void *)((wxBitmapButton *)  ((wxContextHelpButton *) x));
36069 }
36070 static void *_p_wxSimpleHelpProviderTo_p_wxHelpProvider(void *x) {
36071     return (void *)((wxHelpProvider *)  ((wxSimpleHelpProvider *) x));
36072 }
36073 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36074     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
36075 }
36076 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36077     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36078 }
36079 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36080     return (void *)((wxObject *)  ((wxSizerItem *) x));
36081 }
36082 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36083     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36084 }
36085 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36086     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
36087 }
36088 static void *_p_wxTextUrlEventTo_p_wxObject(void *x) {
36089     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxTextUrlEvent *) x));
36090 }
36091 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36092     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36093 }
36094 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36095     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36096 }
36097 static void *_p_wxSizerTo_p_wxObject(void *x) {
36098     return (void *)((wxObject *)  ((wxSizer *) x));
36099 }
36100 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36101     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36102 }
36103 static void *_p_wxCheckBoxTo_p_wxObject(void *x) {
36104     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxCheckBox *) x));
36105 }
36106 static void *_p_wxPyTreeCtrlTo_p_wxObject(void *x) {
36107     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
36108 }
36109 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36110     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36111 }
36112 static void *_p_wxEventTo_p_wxObject(void *x) {
36113     return (void *)((wxObject *)  ((wxEvent *) x));
36114 }
36115 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36116     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36117 }
36118 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36119     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36120 }
36121 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36122     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36123 }
36124 static void *_p_wxGenericDirCtrlTo_p_wxObject(void *x) {
36125     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
36126 }
36127 static void *_p_wxPyListCtrlTo_p_wxObject(void *x) {
36128     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
36129 }
36130 static void *_p_wxDirFilterListCtrlTo_p_wxObject(void *x) {
36131     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
36132 }
36133 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36134     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36135 }
36136 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36137     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36138 }
36139 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36140     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36141 }
36142 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36143     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36144 }
36145 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36146     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36147 }
36148 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36149     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36150 }
36151 static void *_p_wxStaticLineTo_p_wxObject(void *x) {
36152     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticLine *) x));
36153 }
36154 static void *_p_wxControlTo_p_wxObject(void *x) {
36155     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36156 }
36157 static void *_p_wxPyControlTo_p_wxObject(void *x) {
36158     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyControl *) x));
36159 }
36160 static void *_p_wxGaugeTo_p_wxObject(void *x) {
36161     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGauge *) x));
36162 }
36163 static void *_p_wxRadioButtonTo_p_wxObject(void *x) {
36164     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioButton *) x));
36165 }
36166 static void *_p_wxToggleButtonTo_p_wxObject(void *x) {
36167     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxToggleButton *) x));
36168 }
36169 static void *_p_wxToolBarBaseTo_p_wxObject(void *x) {
36170     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxToolBarBase *) x));
36171 }
36172 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36173     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36174 }
36175 static void *_p_wxChoiceTo_p_wxObject(void *x) {
36176     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
36177 }
36178 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36179     return (void *)((wxObject *)  ((wxFSFile *) x));
36180 }
36181 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36182     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36183 }
36184 static void *_p_wxListViewTo_p_wxObject(void *x) {
36185     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
36186 }
36187 static void *_p_wxTextCtrlTo_p_wxObject(void *x) {
36188     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxTextCtrl *) x));
36189 }
36190 static void *_p_wxNotebookTo_p_wxObject(void *x) {
36191     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
36192 }
36193 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36194     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36195 }
36196 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36197     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
36198 }
36199 static void *_p_wxChoicebookTo_p_wxObject(void *x) {
36200     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
36201 }
36202 static void *_p_wxListbookTo_p_wxObject(void *x) {
36203     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
36204 }
36205 static void *_p_wxShowEventTo_p_wxObject(void *x) {
36206     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
36207 }
36208 static void *_p_wxStaticBitmapTo_p_wxObject(void *x) {
36209     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
36210 }
36211 static void *_p_wxSliderTo_p_wxObject(void *x) {
36212     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSlider *) x));
36213 }
36214 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
36215     return (void *)((wxObject *)  ((wxMenuItem *) x));
36216 }
36217 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
36218     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
36219 }
36220 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
36221     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
36222 }
36223 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
36224     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
36225 }
36226 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
36227     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
36228 }
36229 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
36230     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
36231 }
36232 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
36233     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
36234 }
36235 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
36236     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
36237 }
36238 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
36239     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
36240 }
36241 static void *_p_wxStaticBoxTo_p_wxObject(void *x) {
36242     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBox *) x));
36243 }
36244 static void *_p_wxContextHelpTo_p_wxObject(void *x) {
36245     return (void *)((wxObject *)  ((wxContextHelp *) x));
36246 }
36247 static void *_p_wxBookCtrlBaseTo_p_wxObject(void *x) {
36248     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
36249 }
36250 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
36251     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
36252 }
36253 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
36254     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
36255 }
36256 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
36257     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
36258 }
36259 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
36260     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
36261 }
36262 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
36263     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
36264 }
36265 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
36266     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
36267 }
36268 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
36269     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
36270 }
36271 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
36272     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
36273 }
36274 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
36275     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
36276 }
36277 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
36278     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
36279 }
36280 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
36281     return (void *)((wxObject *)  ((wxImageHandler *) x));
36282 }
36283 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
36284     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
36285 }
36286 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
36287     return (void *)((wxObject *)  ((wxEvtHandler *) x));
36288 }
36289 static void *_p_wxListEventTo_p_wxObject(void *x) {
36290     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
36291 }
36292 static void *_p_wxListBoxTo_p_wxObject(void *x) {
36293     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
36294 }
36295 static void *_p_wxCheckListBoxTo_p_wxObject(void *x) {
36296     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
36297 }
36298 static void *_p_wxButtonTo_p_wxObject(void *x) {
36299     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxButton *) x));
36300 }
36301 static void *_p_wxBitmapButtonTo_p_wxObject(void *x) {
36302     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxButton *) ((wxBitmapButton *) x));
36303 }
36304 static void *_p_wxSpinButtonTo_p_wxObject(void *x) {
36305     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinButton *) x));
36306 }
36307 static void *_p_wxContextHelpButtonTo_p_wxObject(void *x) {
36308     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36309 }
36310 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
36311     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
36312 }
36313 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
36314     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
36315 }
36316 static void *_p_wxScrollBarTo_p_wxObject(void *x) {
36317     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxScrollBar *) x));
36318 }
36319 static void *_p_wxRadioBoxTo_p_wxObject(void *x) {
36320     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioBox *) x));
36321 }
36322 static void *_p_wxComboBoxTo_p_wxObject(void *x) {
36323     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
36324 }
36325 static void *_p_wxHelpEventTo_p_wxObject(void *x) {
36326     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxHelpEvent *) x));
36327 }
36328 static void *_p_wxListItemTo_p_wxObject(void *x) {
36329     return (void *)((wxObject *)  ((wxListItem *) x));
36330 }
36331 static void *_p_wxImageTo_p_wxObject(void *x) {
36332     return (void *)((wxObject *)  ((wxImage *) x));
36333 }
36334 static void *_p_wxNotebookSizerTo_p_wxObject(void *x) {
36335     return (void *)((wxObject *) (wxSizer *) ((wxNotebookSizer *) x));
36336 }
36337 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
36338     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
36339 }
36340 static void *_p_wxSpinEventTo_p_wxObject(void *x) {
36341     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
36342 }
36343 static void *_p_wxGenericDragImageTo_p_wxObject(void *x) {
36344     return (void *)((wxObject *)  ((wxGenericDragImage *) x));
36345 }
36346 static void *_p_wxSpinCtrlTo_p_wxObject(void *x) {
36347     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
36348 }
36349 static void *_p_wxNotebookEventTo_p_wxObject(void *x) {
36350     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
36351 }
36352 static void *_p_wxListbookEventTo_p_wxObject(void *x) {
36353     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
36354 }
36355 static void *_p_wxChoicebookEventTo_p_wxObject(void *x) {
36356     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
36357 }
36358 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
36359     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36360 }
36361 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
36362     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
36363 }
36364 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
36365     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
36366 }
36367 static void *_p_wxWindowTo_p_wxObject(void *x) {
36368     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
36369 }
36370 static void *_p_wxMenuTo_p_wxObject(void *x) {
36371     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
36372 }
36373 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
36374     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
36375 }
36376 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
36377     return (void *)((wxObject *)  ((wxFileSystem *) x));
36378 }
36379 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
36380     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
36381 }
36382 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
36383     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
36384 }
36385 static void *_p_wxPyAppTo_p_wxObject(void *x) {
36386     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
36387 }
36388 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
36389     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
36390 }
36391 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
36392     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
36393 }
36394 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
36395     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
36396 }
36397 static void *_p_wxBookCtrlBaseEventTo_p_wxObject(void *x) {
36398     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
36399 }
36400 static void *_p_wxTreeEventTo_p_wxObject(void *x) {
36401     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
36402 }
36403 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
36404     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
36405 }
36406 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
36407     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
36408 }
36409 static void *_p_wxStaticTextTo_p_wxObject(void *x) {
36410     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticText *) x));
36411 }
36412 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
36413     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
36414 }
36415 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
36416     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
36417 }
36418 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
36419     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
36420 }
36421 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
36422     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36423 }
36424 static void *_p_wxToolBarToolBaseTo_p_wxObject(void *x) {
36425     return (void *)((wxObject *)  ((wxToolBarToolBase *) x));
36426 }
36427 static void *_p_wxToolBarTo_p_wxObject(void *x) {
36428     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
36429 }
36430 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
36431     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
36432 }
36433 static void *_p_wxValidatorTo_p_wxObject(void *x) {
36434     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
36435 }
36436 static void *_p_wxBookCtrlSizerTo_p_wxObject(void *x) {
36437     return (void *)((wxObject *) (wxSizer *) ((wxBookCtrlSizer *) x));
36438 }
36439 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
36440     return (void *)((wxWindow *)  ((wxMenuBar *) x));
36441 }
36442 static void *_p_wxBookCtrlBaseTo_p_wxWindow(void *x) {
36443     return (void *)((wxWindow *) (wxControl *) ((wxBookCtrlBase *) x));
36444 }
36445 static void *_p_wxToolBarTo_p_wxWindow(void *x) {
36446     return (void *)((wxWindow *) (wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
36447 }
36448 static void *_p_wxToggleButtonTo_p_wxWindow(void *x) {
36449     return (void *)((wxWindow *) (wxControl *) ((wxToggleButton *) x));
36450 }
36451 static void *_p_wxRadioButtonTo_p_wxWindow(void *x) {
36452     return (void *)((wxWindow *) (wxControl *) ((wxRadioButton *) x));
36453 }
36454 static void *_p_wxControlTo_p_wxWindow(void *x) {
36455     return (void *)((wxWindow *)  ((wxControl *) x));
36456 }
36457 static void *_p_wxToolBarBaseTo_p_wxWindow(void *x) {
36458     return (void *)((wxWindow *) (wxControl *) ((wxToolBarBase *) x));
36459 }
36460 static void *_p_wxDirFilterListCtrlTo_p_wxWindow(void *x) {
36461     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
36462 }
36463 static void *_p_wxPyListCtrlTo_p_wxWindow(void *x) {
36464     return (void *)((wxWindow *) (wxControl *) ((wxPyListCtrl *) x));
36465 }
36466 static void *_p_wxComboBoxTo_p_wxWindow(void *x) {
36467     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxChoice *) ((wxComboBox *) x));
36468 }
36469 static void *_p_wxPyControlTo_p_wxWindow(void *x) {
36470     return (void *)((wxWindow *) (wxControl *) ((wxPyControl *) x));
36471 }
36472 static void *_p_wxGenericDirCtrlTo_p_wxWindow(void *x) {
36473     return (void *)((wxWindow *) (wxControl *) ((wxGenericDirCtrl *) x));
36474 }
36475 static void *_p_wxScrollBarTo_p_wxWindow(void *x) {
36476     return (void *)((wxWindow *) (wxControl *) ((wxScrollBar *) x));
36477 }
36478 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
36479     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
36480 }
36481 static void *_p_wxGaugeTo_p_wxWindow(void *x) {
36482     return (void *)((wxWindow *) (wxControl *) ((wxGauge *) x));
36483 }
36484 static void *_p_wxStaticLineTo_p_wxWindow(void *x) {
36485     return (void *)((wxWindow *) (wxControl *) ((wxStaticLine *) x));
36486 }
36487 static void *_p_wxChoicebookTo_p_wxWindow(void *x) {
36488     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
36489 }
36490 static void *_p_wxListbookTo_p_wxWindow(void *x) {
36491     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
36492 }
36493 static void *_p_wxPyTreeCtrlTo_p_wxWindow(void *x) {
36494     return (void *)((wxWindow *) (wxControl *) ((wxPyTreeCtrl *) x));
36495 }
36496 static void *_p_wxCheckBoxTo_p_wxWindow(void *x) {
36497     return (void *)((wxWindow *) (wxControl *) ((wxCheckBox *) x));
36498 }
36499 static void *_p_wxRadioBoxTo_p_wxWindow(void *x) {
36500     return (void *)((wxWindow *) (wxControl *) ((wxRadioBox *) x));
36501 }
36502 static void *_p_wxCheckListBoxTo_p_wxWindow(void *x) {
36503     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
36504 }
36505 static void *_p_wxChoiceTo_p_wxWindow(void *x) {
36506     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxChoice *) x));
36507 }
36508 static void *_p_wxListBoxTo_p_wxWindow(void *x) {
36509     return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxListBox *) x));
36510 }
36511 static void *_p_wxListViewTo_p_wxWindow(void *x) {
36512     return (void *)((wxWindow *) (wxControl *)(wxPyListCtrl *) ((wxListView *) x));
36513 }
36514 static void *_p_wxNotebookTo_p_wxWindow(void *x) {
36515     return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
36516 }
36517 static void *_p_wxStaticBitmapTo_p_wxWindow(void *x) {
36518     return (void *)((wxWindow *) (wxControl *) ((wxStaticBitmap *) x));
36519 }
36520 static void *_p_wxSpinCtrlTo_p_wxWindow(void *x) {
36521     return (void *)((wxWindow *) (wxControl *) ((wxSpinCtrl *) x));
36522 }
36523 static void *_p_wxStaticTextTo_p_wxWindow(void *x) {
36524     return (void *)((wxWindow *) (wxControl *) ((wxStaticText *) x));
36525 }
36526 static void *_p_wxStaticBoxTo_p_wxWindow(void *x) {
36527     return (void *)((wxWindow *) (wxControl *) ((wxStaticBox *) x));
36528 }
36529 static void *_p_wxSliderTo_p_wxWindow(void *x) {
36530     return (void *)((wxWindow *) (wxControl *) ((wxSlider *) x));
36531 }
36532 static void *_p_wxSpinButtonTo_p_wxWindow(void *x) {
36533     return (void *)((wxWindow *) (wxControl *) ((wxSpinButton *) x));
36534 }
36535 static void *_p_wxButtonTo_p_wxWindow(void *x) {
36536     return (void *)((wxWindow *) (wxControl *) ((wxButton *) x));
36537 }
36538 static void *_p_wxBitmapButtonTo_p_wxWindow(void *x) {
36539     return (void *)((wxWindow *) (wxControl *)(wxButton *) ((wxBitmapButton *) x));
36540 }
36541 static void *_p_wxContextHelpButtonTo_p_wxWindow(void *x) {
36542     return (void *)((wxWindow *) (wxControl *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
36543 }
36544 static void *_p_wxTextCtrlTo_p_wxWindow(void *x) {
36545     return (void *)((wxWindow *) (wxControl *) ((wxTextCtrl *) x));
36546 }
36547 static void *_p_wxNotebookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36548     return (void *)((wxBookCtrlBaseEvent *)  ((wxNotebookEvent *) x));
36549 }
36550 static void *_p_wxListbookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36551     return (void *)((wxBookCtrlBaseEvent *)  ((wxListbookEvent *) x));
36552 }
36553 static void *_p_wxChoicebookEventTo_p_wxBookCtrlBaseEvent(void *x) {
36554     return (void *)((wxBookCtrlBaseEvent *)  ((wxChoicebookEvent *) x));
36555 }
36556 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
36557     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
36558 }
36559 static void *_p_wxTextUrlEventTo_p_wxCommandEvent(void *x) {
36560     return (void *)((wxCommandEvent *)  ((wxTextUrlEvent *) x));
36561 }
36562 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
36563     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
36564 }
36565 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
36566     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
36567 }
36568 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
36569     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
36570 }
36571 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
36572     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
36573 }
36574 static void *_p_wxChoicebookEventTo_p_wxCommandEvent(void *x) {
36575     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxChoicebookEvent *) x));
36576 }
36577 static void *_p_wxListbookEventTo_p_wxCommandEvent(void *x) {
36578     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxListbookEvent *) x));
36579 }
36580 static void *_p_wxNotebookEventTo_p_wxCommandEvent(void *x) {
36581     return (void *)((wxCommandEvent *) (wxNotifyEvent *)(wxBookCtrlBaseEvent *) ((wxNotebookEvent *) x));
36582 }
36583 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
36584     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
36585 }
36586 static void *_p_wxListEventTo_p_wxCommandEvent(void *x) {
36587     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxListEvent *) x));
36588 }
36589 static void *_p_wxBookCtrlBaseEventTo_p_wxCommandEvent(void *x) {
36590     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxBookCtrlBaseEvent *) x));
36591 }
36592 static void *_p_wxTreeEventTo_p_wxCommandEvent(void *x) {
36593     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxTreeEvent *) x));
36594 }
36595 static void *_p_wxSpinEventTo_p_wxCommandEvent(void *x) {
36596     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSpinEvent *) x));
36597 }
36598 static void *_p_wxHelpEventTo_p_wxCommandEvent(void *x) {
36599     return (void *)((wxCommandEvent *)  ((wxHelpEvent *) x));
36600 }
36601 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
36602     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
36603 }
36604 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
36605     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
36606 }
36607 static void *_p_wxComboBoxTo_p_wxControlWithItems(void *x) {
36608     return (void *)((wxControlWithItems *) (wxChoice *) ((wxComboBox *) x));
36609 }
36610 static void *_p_wxDirFilterListCtrlTo_p_wxControlWithItems(void *x) {
36611     return (void *)((wxControlWithItems *) (wxChoice *) ((wxDirFilterListCtrl *) x));
36612 }
36613 static void *_p_wxChoiceTo_p_wxControlWithItems(void *x) {
36614     return (void *)((wxControlWithItems *)  ((wxChoice *) x));
36615 }
36616 static void *_p_wxListBoxTo_p_wxControlWithItems(void *x) {
36617     return (void *)((wxControlWithItems *)  ((wxListBox *) x));
36618 }
36619 static void *_p_wxCheckListBoxTo_p_wxControlWithItems(void *x) {
36620     return (void *)((wxControlWithItems *) (wxListBox *) ((wxCheckListBox *) x));
36621 }
36622 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
36623     return (void *)((wxValidator *)  ((wxPyValidator *) x));
36624 }
36625 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}};
36626 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}};
36627 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}};
36628 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}};
36629 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}};
36630 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}};
36631 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}};
36632 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}};
36633 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}};
36634 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}};
36635 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}};
36636 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}};
36637 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}};
36638 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}};
36639 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}};
36640 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}};
36641 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}};
36642 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}};
36643 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}};
36644 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}};
36645 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}};
36646 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}};
36647 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}};
36648 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}};
36649 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}};
36650 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}};
36651 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}};
36652 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}};
36653 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}};
36654 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}};
36655 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}};
36656 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}};
36657 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}};
36658 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}};
36659 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}};
36660 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}};
36661 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}};
36662 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}};
36663 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}};
36664 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}};
36665 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}};
36666 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}};
36667 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}};
36668 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}};
36669 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}};
36670 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}};
36671 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}};
36672 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}};
36673 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}};
36674 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}};
36675 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}};
36676 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}};
36677 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}};
36678 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}};
36679 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}};
36680 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}};
36681 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}};
36682 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}};
36683 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}};
36684 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}};
36685 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}};
36686 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}};
36687 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}};
36688 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}};
36689 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}};
36690 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}};
36691 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}};
36692 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}};
36693 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}};
36694 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}};
36695 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}};
36696 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}};
36697 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}};
36698 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}};
36699 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}};
36700 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}};
36701 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}};
36702 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}};
36703 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}};
36704 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}};
36705 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}};
36706 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}};
36707 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}};
36708 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}};
36709 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}};
36710 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}};
36711 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}};
36712 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}};
36713 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}};
36714 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}};
36715 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}};
36716 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}};
36717 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}};
36718 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}};
36719 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}};
36720 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}};
36721
36722 static swig_type_info *swig_types_initial[] = {
36723 _swigt__p_wxTextUrlEvent,
36724 _swigt__p_wxSizer,
36725 _swigt__p_wxCheckBox,
36726 _swigt__p_wxPyTreeCtrl,
36727 _swigt__p_wxEvent,
36728 _swigt__p_wxGenericDirCtrl,
36729 _swigt__p_bool,
36730 _swigt__p_wxItemContainer,
36731 _swigt__p_wxPyListCtrl,
36732 _swigt__p_wxPyTreeItemData,
36733 _swigt__p_wxDirFilterListCtrl,
36734 _swigt__p_wxStaticLine,
36735 _swigt__p_wxControl,
36736 _swigt__p_wxPyControl,
36737 _swigt__p_wxGauge,
36738 _swigt__p_wxToolBarBase,
36739 _swigt__p_wxFont,
36740 _swigt__p_wxToggleButton,
36741 _swigt__p_wxRadioButton,
36742 _swigt__p_wxChoice,
36743 _swigt__p_wxMemoryDC,
36744 _swigt__ptrdiff_t,
36745 _swigt__std__ptrdiff_t,
36746 _swigt__p_wxListItemAttr,
36747 _swigt__p_void,
36748 _swigt__p_int,
36749 _swigt__p_wxSize,
36750 _swigt__p_wxDC,
36751 _swigt__p_wxListView,
36752 _swigt__p_wxIcon,
36753 _swigt__p_wxVisualAttributes,
36754 _swigt__p_wxTextCtrl,
36755 _swigt__p_wxNotebook,
36756 _swigt__p_wxChoicebook,
36757 _swigt__p_wxNotifyEvent,
36758 _swigt__p_wxArrayString,
36759 _swigt__p_form_ops_t,
36760 _swigt__p_wxListbook,
36761 _swigt__p_wxStaticBitmap,
36762 _swigt__p_wxSlider,
36763 _swigt__p_wxStaticBox,
36764 _swigt__p_wxArrayInt,
36765 _swigt__p_wxContextHelp,
36766 _swigt__p_long,
36767 _swigt__p_wxDuplexMode,
36768 _swigt__p_wxBookCtrlBase,
36769 _swigt__p_wxEvtHandler,
36770 _swigt__p_wxListEvent,
36771 _swigt__p_wxCheckListBox,
36772 _swigt__p_wxListBox,
36773 _swigt__p_wxSpinButton,
36774 _swigt__p_wxButton,
36775 _swigt__p_wxBitmapButton,
36776 _swigt__p_wxRect,
36777 _swigt__p_wxContextHelpButton,
36778 _swigt__p_wxRadioBox,
36779 _swigt__p_wxScrollBar,
36780 _swigt__p_char,
36781 _swigt__p_wxComboBox,
36782 _swigt__p_wxTreeItemId,
36783 _swigt__p_wxHelpEvent,
36784 _swigt__p_wxListItem,
36785 _swigt__p_wxNotebookSizer,
36786 _swigt__p_wxSpinEvent,
36787 _swigt__p_wxGenericDragImage,
36788 _swigt__p_wxSpinCtrl,
36789 _swigt__p_wxPaperSize,
36790 _swigt__p_wxImageList,
36791 _swigt__p_wxHelpProvider,
36792 _swigt__p_wxTextAttr,
36793 _swigt__p_wxSimpleHelpProvider,
36794 _swigt__p_wxChoicebookEvent,
36795 _swigt__p_wxListbookEvent,
36796 _swigt__p_wxNotebookEvent,
36797 _swigt__p_wxPoint,
36798 _swigt__p_wxObject,
36799 _swigt__p_wxCursor,
36800 _swigt__p_wxKeyEvent,
36801 _swigt__p_unsigned_long,
36802 _swigt__p_wxWindow,
36803 _swigt__p_wxString,
36804 _swigt__p_wxBitmap,
36805 _swigt__unsigned_int,
36806 _swigt__p_unsigned_int,
36807 _swigt__p_unsigned_char,
36808 _swigt__p_wxMouseEvent,
36809 _swigt__p_wxBookCtrlBaseEvent,
36810 _swigt__p_wxTreeEvent,
36811 _swigt__p_wxCommandEvent,
36812 _swigt__p_wxStaticText,
36813 _swigt__p_wxControlWithItems,
36814 _swigt__p_wxToolBarToolBase,
36815 _swigt__p_wxColour,
36816 _swigt__p_wxToolBar,
36817 _swigt__p_wxBookCtrlSizer,
36818 _swigt__p_wxValidator,
36819 0
36820 };
36821
36822
36823 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
36824
36825 static swig_const_info swig_const_table[] = {
36826 {0, 0, 0, 0.0, 0, 0}};
36827
36828 #ifdef __cplusplus
36829 }
36830 #endif
36831
36832
36833 #ifdef __cplusplus
36834 extern "C" {
36835 #endif
36836
36837     /* Python-specific SWIG API */
36838 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
36839 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
36840 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
36841
36842     /* -----------------------------------------------------------------------------
36843      * global variable support code.
36844      * ----------------------------------------------------------------------------- */
36845
36846     typedef struct swig_globalvar {
36847         char       *name;                  /* Name of global variable */
36848         PyObject *(*get_attr)();           /* Return the current value */
36849         int       (*set_attr)(PyObject *); /* Set the value */
36850         struct swig_globalvar *next;
36851     } swig_globalvar;
36852
36853     typedef struct swig_varlinkobject {
36854         PyObject_HEAD
36855         swig_globalvar *vars;
36856     } swig_varlinkobject;
36857
36858     static PyObject *
36859     swig_varlink_repr(swig_varlinkobject *v) {
36860         v = v;
36861         return PyString_FromString("<Swig global variables>");
36862     }
36863
36864     static int
36865     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
36866         swig_globalvar  *var;
36867         flags = flags;
36868         fprintf(fp,"Swig global variables { ");
36869         for (var = v->vars; var; var=var->next) {
36870             fprintf(fp,"%s", var->name);
36871             if (var->next) fprintf(fp,", ");
36872         }
36873         fprintf(fp," }\n");
36874         return 0;
36875     }
36876
36877     static PyObject *
36878     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
36879         swig_globalvar *var = v->vars;
36880         while (var) {
36881             if (strcmp(var->name,n) == 0) {
36882                 return (*var->get_attr)();
36883             }
36884             var = var->next;
36885         }
36886         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36887         return NULL;
36888     }
36889
36890     static int
36891     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
36892         swig_globalvar *var = v->vars;
36893         while (var) {
36894             if (strcmp(var->name,n) == 0) {
36895                 return (*var->set_attr)(p);
36896             }
36897             var = var->next;
36898         }
36899         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
36900         return 1;
36901     }
36902
36903     static PyTypeObject varlinktype = {
36904         PyObject_HEAD_INIT(0)
36905         0,                                  /* Number of items in variable part (ob_size) */
36906         (char *)"swigvarlink",              /* Type name (tp_name) */
36907         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
36908         0,                                  /* Itemsize (tp_itemsize) */
36909         0,                                  /* Deallocator (tp_dealloc) */
36910         (printfunc) swig_varlink_print,     /* Print (tp_print) */
36911         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
36912         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
36913         0,                                  /* tp_compare */
36914         (reprfunc) swig_varlink_repr,       /* tp_repr */
36915         0,                                  /* tp_as_number */
36916         0,                                  /* tp_as_sequence */
36917         0,                                  /* tp_as_mapping */
36918         0,                                  /* tp_hash */
36919         0,                                  /* tp_call */
36920         0,                                  /* tp_str */
36921         0,                                  /* tp_getattro */
36922         0,                                  /* tp_setattro */
36923         0,                                  /* tp_as_buffer */
36924         0,                                  /* tp_flags */
36925         0,                                  /* tp_doc */
36926 #if PY_VERSION_HEX >= 0x02000000
36927         0,                                  /* tp_traverse */
36928         0,                                  /* tp_clear */
36929 #endif
36930 #if PY_VERSION_HEX >= 0x02010000
36931         0,                                  /* tp_richcompare */
36932         0,                                  /* tp_weaklistoffset */
36933 #endif
36934 #if PY_VERSION_HEX >= 0x02020000
36935         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
36936 #endif
36937 #if PY_VERSION_HEX >= 0x02030000
36938         0,                                  /* tp_del */
36939 #endif
36940 #ifdef COUNT_ALLOCS
36941         0,0,0,0                             /* tp_alloc -> tp_next */
36942 #endif
36943     };
36944
36945     /* Create a variable linking object for use later */
36946     static PyObject *
36947     SWIG_Python_newvarlink(void) {
36948         swig_varlinkobject *result = 0;
36949         result = PyMem_NEW(swig_varlinkobject,1);
36950         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
36951         result->ob_type = &varlinktype;
36952         result->vars = 0;
36953         result->ob_refcnt = 0;
36954         Py_XINCREF((PyObject *) result);
36955         return ((PyObject*) result);
36956     }
36957
36958     static void
36959     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
36960         swig_varlinkobject *v;
36961         swig_globalvar *gv;
36962         v= (swig_varlinkobject *) p;
36963         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
36964         gv->name = (char *) malloc(strlen(name)+1);
36965         strcpy(gv->name,name);
36966         gv->get_attr = get_attr;
36967         gv->set_attr = set_attr;
36968         gv->next = v->vars;
36969         v->vars = gv;
36970     }
36971
36972     /* -----------------------------------------------------------------------------
36973      * constants/methods manipulation
36974      * ----------------------------------------------------------------------------- */
36975
36976     /* Install Constants */
36977     static void
36978     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
36979         PyObject *obj = 0;
36980         size_t i;
36981         for (i = 0; constants[i].type; i++) {
36982             switch(constants[i].type) {
36983                 case SWIG_PY_INT:
36984                 obj = PyInt_FromLong(constants[i].lvalue);
36985                 break;
36986                 case SWIG_PY_FLOAT:
36987                 obj = PyFloat_FromDouble(constants[i].dvalue);
36988                 break;
36989                 case SWIG_PY_STRING:
36990                 if (constants[i].pvalue) {
36991                     obj = PyString_FromString((char *) constants[i].pvalue);
36992                 } else {
36993                     Py_INCREF(Py_None);
36994                     obj = Py_None;
36995                 }
36996                 break;
36997                 case SWIG_PY_POINTER:
36998                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
36999                 break;
37000                 case SWIG_PY_BINARY:
37001                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
37002                 break;
37003                 default:
37004                 obj = 0;
37005                 break;
37006             }
37007             if (obj) {
37008                 PyDict_SetItemString(d,constants[i].name,obj);
37009                 Py_DECREF(obj);
37010             }
37011         }
37012     }
37013
37014     /* -----------------------------------------------------------------------------*/
37015     /* Fix SwigMethods to carry the callback ptrs when needed */
37016     /* -----------------------------------------------------------------------------*/
37017
37018     static void
37019     SWIG_Python_FixMethods(PyMethodDef *methods,
37020     swig_const_info *const_table,
37021     swig_type_info **types,
37022     swig_type_info **types_initial) {
37023         size_t i;
37024         for (i = 0; methods[i].ml_name; ++i) {
37025             char *c = methods[i].ml_doc;
37026             if (c && (c = strstr(c, "swig_ptr: "))) {
37027                 int j;
37028                 swig_const_info *ci = 0;
37029                 char *name = c + 10;
37030                 for (j = 0; const_table[j].type; j++) {
37031                     if (strncmp(const_table[j].name, name,
37032                     strlen(const_table[j].name)) == 0) {
37033                         ci = &(const_table[j]);
37034                         break;
37035                     }
37036                 }
37037                 if (ci) {
37038                     size_t shift = (ci->ptype) - types;
37039                     swig_type_info *ty = types_initial[shift];
37040                     size_t ldoc = (c - methods[i].ml_doc);
37041                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
37042                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
37043                     char *buff = ndoc;
37044                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
37045                     strncpy(buff, methods[i].ml_doc, ldoc);
37046                     buff += ldoc;
37047                     strncpy(buff, "swig_ptr: ", 10);
37048                     buff += 10;
37049                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
37050                     methods[i].ml_doc = ndoc;
37051                 }
37052             }
37053         }
37054     }
37055
37056     /* -----------------------------------------------------------------------------*
37057      *  Initialize type list
37058      * -----------------------------------------------------------------------------*/
37059
37060 #if PY_MAJOR_VERSION < 2
37061     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
37062     is copied out of Python/modsupport.c in python version 2.3.4 */
37063     static int
37064     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
37065     {
37066         PyObject *dict;
37067         if (!PyModule_Check(m)) {
37068             PyErr_SetString(PyExc_TypeError,
37069             "PyModule_AddObject() needs module as first arg");
37070             return -1;
37071         }
37072         if (!o) {
37073             PyErr_SetString(PyExc_TypeError,
37074             "PyModule_AddObject() needs non-NULL value");
37075             return -1;
37076         }
37077
37078         dict = PyModule_GetDict(m);
37079         if (dict == NULL) {
37080             /* Internal error -- modules must have a dict! */
37081             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
37082             PyModule_GetName(m));
37083             return -1;
37084         }
37085         if (PyDict_SetItemString(dict, name, o))
37086         return -1;
37087         Py_DECREF(o);
37088         return 0;
37089     }
37090 #endif
37091
37092     static swig_type_info **
37093     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
37094         static PyMethodDef swig_empty_runtime_method_table[] = {
37095             {
37096                 NULL, NULL, 0, NULL
37097             }
37098         };/* Sentinel */
37099
37100         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
37101         swig_empty_runtime_method_table);
37102         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
37103         if (pointer && module) {
37104             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
37105         }
37106         return type_list_handle;
37107     }
37108
37109     static swig_type_info **
37110     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
37111         swig_type_info **type_pointer;
37112
37113         /* first check if module already created */
37114         type_pointer = SWIG_Python_GetTypeListHandle();
37115         if (type_pointer) {
37116             return type_pointer;
37117         } else {
37118             /* create a new module and variable */
37119             return SWIG_Python_SetTypeListHandle(type_list_handle);
37120         }
37121     }
37122
37123 #ifdef __cplusplus
37124 }
37125 #endif
37126
37127 /* -----------------------------------------------------------------------------*
37128  *  Partial Init method
37129  * -----------------------------------------------------------------------------*/
37130
37131 #ifdef SWIG_LINK_RUNTIME
37132 #ifdef __cplusplus
37133 extern "C"
37134 #endif
37135 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
37136 #endif
37137
37138 #ifdef __cplusplus
37139 extern "C"
37140 #endif
37141 SWIGEXPORT(void) SWIG_init(void) {
37142     static PyObject *SWIG_globals = 0;
37143     static int       typeinit = 0;
37144     PyObject *m, *d;
37145     int       i;
37146     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
37147
37148     /* Fix SwigMethods to carry the callback ptrs when needed */
37149     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
37150
37151     m = Py_InitModule((char *) SWIG_name, SwigMethods);
37152     d = PyModule_GetDict(m);
37153
37154     if (!typeinit) {
37155 #ifdef SWIG_LINK_RUNTIME
37156         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
37157 #else
37158 #  ifndef SWIG_STATIC_RUNTIME
37159         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
37160 #  endif
37161 #endif
37162         for (i = 0; swig_types_initial[i]; i++) {
37163             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
37164         }
37165         typeinit = 1;
37166     }
37167     SWIG_InstallConstants(d,swig_const_table);
37168
37169     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
37170     SWIG_addvarlink(SWIG_globals,(char*)"ButtonNameStr",_wrap_ButtonNameStr_get, _wrap_ButtonNameStr_set);
37171     {
37172         PyDict_SetItemString(d,"BU_LEFT", SWIG_From_int((int)(wxBU_LEFT)));
37173     }
37174     {
37175         PyDict_SetItemString(d,"BU_TOP", SWIG_From_int((int)(wxBU_TOP)));
37176     }
37177     {
37178         PyDict_SetItemString(d,"BU_RIGHT", SWIG_From_int((int)(wxBU_RIGHT)));
37179     }
37180     {
37181         PyDict_SetItemString(d,"BU_BOTTOM", SWIG_From_int((int)(wxBU_BOTTOM)));
37182     }
37183     {
37184         PyDict_SetItemString(d,"BU_ALIGN_MASK", SWIG_From_int((int)(wxBU_ALIGN_MASK)));
37185     }
37186     {
37187         PyDict_SetItemString(d,"BU_EXACTFIT", SWIG_From_int((int)(wxBU_EXACTFIT)));
37188     }
37189     {
37190         PyDict_SetItemString(d,"BU_AUTODRAW", SWIG_From_int((int)(wxBU_AUTODRAW)));
37191     }
37192     SWIG_addvarlink(SWIG_globals,(char*)"CheckBoxNameStr",_wrap_CheckBoxNameStr_get, _wrap_CheckBoxNameStr_set);
37193     {
37194         PyDict_SetItemString(d,"CHK_2STATE", SWIG_From_int((int)(wxCHK_2STATE)));
37195     }
37196     {
37197         PyDict_SetItemString(d,"CHK_3STATE", SWIG_From_int((int)(wxCHK_3STATE)));
37198     }
37199     {
37200         PyDict_SetItemString(d,"CHK_ALLOW_3RD_STATE_FOR_USER", SWIG_From_int((int)(wxCHK_ALLOW_3RD_STATE_FOR_USER)));
37201     }
37202     {
37203         PyDict_SetItemString(d,"CHK_UNCHECKED", SWIG_From_int((int)(wxCHK_UNCHECKED)));
37204     }
37205     {
37206         PyDict_SetItemString(d,"CHK_CHECKED", SWIG_From_int((int)(wxCHK_CHECKED)));
37207     }
37208     {
37209         PyDict_SetItemString(d,"CHK_UNDETERMINED", SWIG_From_int((int)(wxCHK_UNDETERMINED)));
37210     }
37211     SWIG_addvarlink(SWIG_globals,(char*)"ChoiceNameStr",_wrap_ChoiceNameStr_get, _wrap_ChoiceNameStr_set);
37212     SWIG_addvarlink(SWIG_globals,(char*)"ComboBoxNameStr",_wrap_ComboBoxNameStr_get, _wrap_ComboBoxNameStr_set);
37213     SWIG_addvarlink(SWIG_globals,(char*)"GaugeNameStr",_wrap_GaugeNameStr_get, _wrap_GaugeNameStr_set);
37214     {
37215         PyDict_SetItemString(d,"GA_HORIZONTAL", SWIG_From_int((int)(wxGA_HORIZONTAL)));
37216     }
37217     {
37218         PyDict_SetItemString(d,"GA_VERTICAL", SWIG_From_int((int)(wxGA_VERTICAL)));
37219     }
37220     {
37221         PyDict_SetItemString(d,"GA_SMOOTH", SWIG_From_int((int)(wxGA_SMOOTH)));
37222     }
37223     {
37224         PyDict_SetItemString(d,"GA_PROGRESSBAR", SWIG_From_int((int)(wxGA_PROGRESSBAR)));
37225     }
37226     SWIG_addvarlink(SWIG_globals,(char*)"StaticBitmapNameStr",_wrap_StaticBitmapNameStr_get, _wrap_StaticBitmapNameStr_set);
37227     SWIG_addvarlink(SWIG_globals,(char*)"StaticBoxNameStr",_wrap_StaticBoxNameStr_get, _wrap_StaticBoxNameStr_set);
37228     SWIG_addvarlink(SWIG_globals,(char*)"StaticTextNameStr",_wrap_StaticTextNameStr_get, _wrap_StaticTextNameStr_set);
37229     SWIG_addvarlink(SWIG_globals,(char*)"ListBoxNameStr",_wrap_ListBoxNameStr_get, _wrap_ListBoxNameStr_set);
37230     SWIG_addvarlink(SWIG_globals,(char*)"TextCtrlNameStr",_wrap_TextCtrlNameStr_get, _wrap_TextCtrlNameStr_set);
37231     {
37232         PyDict_SetItemString(d,"TE_NO_VSCROLL", SWIG_From_int((int)(wxTE_NO_VSCROLL)));
37233     }
37234     {
37235         PyDict_SetItemString(d,"TE_AUTO_SCROLL", SWIG_From_int((int)(wxTE_AUTO_SCROLL)));
37236     }
37237     {
37238         PyDict_SetItemString(d,"TE_READONLY", SWIG_From_int((int)(wxTE_READONLY)));
37239     }
37240     {
37241         PyDict_SetItemString(d,"TE_MULTILINE", SWIG_From_int((int)(wxTE_MULTILINE)));
37242     }
37243     {
37244         PyDict_SetItemString(d,"TE_PROCESS_TAB", SWIG_From_int((int)(wxTE_PROCESS_TAB)));
37245     }
37246     {
37247         PyDict_SetItemString(d,"TE_LEFT", SWIG_From_int((int)(wxTE_LEFT)));
37248     }
37249     {
37250         PyDict_SetItemString(d,"TE_CENTER", SWIG_From_int((int)(wxTE_CENTER)));
37251     }
37252     {
37253         PyDict_SetItemString(d,"TE_RIGHT", SWIG_From_int((int)(wxTE_RIGHT)));
37254     }
37255     {
37256         PyDict_SetItemString(d,"TE_CENTRE", SWIG_From_int((int)(wxTE_CENTRE)));
37257     }
37258     {
37259         PyDict_SetItemString(d,"TE_RICH", SWIG_From_int((int)(wxTE_RICH)));
37260     }
37261     {
37262         PyDict_SetItemString(d,"TE_PROCESS_ENTER", SWIG_From_int((int)(wxTE_PROCESS_ENTER)));
37263     }
37264     {
37265         PyDict_SetItemString(d,"TE_PASSWORD", SWIG_From_int((int)(wxTE_PASSWORD)));
37266     }
37267     {
37268         PyDict_SetItemString(d,"TE_AUTO_URL", SWIG_From_int((int)(wxTE_AUTO_URL)));
37269     }
37270     {
37271         PyDict_SetItemString(d,"TE_NOHIDESEL", SWIG_From_int((int)(wxTE_NOHIDESEL)));
37272     }
37273     {
37274         PyDict_SetItemString(d,"TE_DONTWRAP", SWIG_From_int((int)(wxTE_DONTWRAP)));
37275     }
37276     {
37277         PyDict_SetItemString(d,"TE_LINEWRAP", SWIG_From_int((int)(wxTE_LINEWRAP)));
37278     }
37279     {
37280         PyDict_SetItemString(d,"TE_WORDWRAP", SWIG_From_int((int)(wxTE_WORDWRAP)));
37281     }
37282     {
37283         PyDict_SetItemString(d,"TE_RICH2", SWIG_From_int((int)(wxTE_RICH2)));
37284     }
37285     {
37286         PyDict_SetItemString(d,"TEXT_ALIGNMENT_DEFAULT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_DEFAULT)));
37287     }
37288     {
37289         PyDict_SetItemString(d,"TEXT_ALIGNMENT_LEFT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_LEFT)));
37290     }
37291     {
37292         PyDict_SetItemString(d,"TEXT_ALIGNMENT_CENTRE", SWIG_From_int((int)(wxTEXT_ALIGNMENT_CENTRE)));
37293     }
37294     {
37295         PyDict_SetItemString(d,"TEXT_ALIGNMENT_CENTER", SWIG_From_int((int)(wxTEXT_ALIGNMENT_CENTER)));
37296     }
37297     {
37298         PyDict_SetItemString(d,"TEXT_ALIGNMENT_RIGHT", SWIG_From_int((int)(wxTEXT_ALIGNMENT_RIGHT)));
37299     }
37300     {
37301         PyDict_SetItemString(d,"TEXT_ALIGNMENT_JUSTIFIED", SWIG_From_int((int)(wxTEXT_ALIGNMENT_JUSTIFIED)));
37302     }
37303     {
37304         PyDict_SetItemString(d,"TEXT_ATTR_TEXT_COLOUR", SWIG_From_int((int)(wxTEXT_ATTR_TEXT_COLOUR)));
37305     }
37306     {
37307         PyDict_SetItemString(d,"TEXT_ATTR_BACKGROUND_COLOUR", SWIG_From_int((int)(wxTEXT_ATTR_BACKGROUND_COLOUR)));
37308     }
37309     {
37310         PyDict_SetItemString(d,"TEXT_ATTR_FONT_FACE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_FACE)));
37311     }
37312     {
37313         PyDict_SetItemString(d,"TEXT_ATTR_FONT_SIZE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_SIZE)));
37314     }
37315     {
37316         PyDict_SetItemString(d,"TEXT_ATTR_FONT_WEIGHT", SWIG_From_int((int)(wxTEXT_ATTR_FONT_WEIGHT)));
37317     }
37318     {
37319         PyDict_SetItemString(d,"TEXT_ATTR_FONT_ITALIC", SWIG_From_int((int)(wxTEXT_ATTR_FONT_ITALIC)));
37320     }
37321     {
37322         PyDict_SetItemString(d,"TEXT_ATTR_FONT_UNDERLINE", SWIG_From_int((int)(wxTEXT_ATTR_FONT_UNDERLINE)));
37323     }
37324     {
37325         PyDict_SetItemString(d,"TEXT_ATTR_FONT", SWIG_From_int((int)(wxTEXT_ATTR_FONT)));
37326     }
37327     {
37328         PyDict_SetItemString(d,"TEXT_ATTR_ALIGNMENT", SWIG_From_int((int)(wxTEXT_ATTR_ALIGNMENT)));
37329     }
37330     {
37331         PyDict_SetItemString(d,"TEXT_ATTR_LEFT_INDENT", SWIG_From_int((int)(wxTEXT_ATTR_LEFT_INDENT)));
37332     }
37333     {
37334         PyDict_SetItemString(d,"TEXT_ATTR_RIGHT_INDENT", SWIG_From_int((int)(wxTEXT_ATTR_RIGHT_INDENT)));
37335     }
37336     {
37337         PyDict_SetItemString(d,"TEXT_ATTR_TABS", SWIG_From_int((int)(wxTEXT_ATTR_TABS)));
37338     }
37339     {
37340         PyDict_SetItemString(d,"TE_HT_UNKNOWN", SWIG_From_int((int)(wxTE_HT_UNKNOWN)));
37341     }
37342     {
37343         PyDict_SetItemString(d,"TE_HT_BEFORE", SWIG_From_int((int)(wxTE_HT_BEFORE)));
37344     }
37345     {
37346         PyDict_SetItemString(d,"TE_HT_ON_TEXT", SWIG_From_int((int)(wxTE_HT_ON_TEXT)));
37347     }
37348     {
37349         PyDict_SetItemString(d,"TE_HT_BELOW", SWIG_From_int((int)(wxTE_HT_BELOW)));
37350     }
37351     {
37352         PyDict_SetItemString(d,"TE_HT_BEYOND", SWIG_From_int((int)(wxTE_HT_BEYOND)));
37353     }
37354     {
37355         PyDict_SetItemString(d,"OutOfRangeTextCoord", SWIG_From_int((int)(wxOutOfRangeTextCoord)));
37356     }
37357     {
37358         PyDict_SetItemString(d,"InvalidTextCoord", SWIG_From_int((int)(wxInvalidTextCoord)));
37359     }
37360     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_UPDATED", PyInt_FromLong(wxEVT_COMMAND_TEXT_UPDATED));
37361     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_ENTER", PyInt_FromLong(wxEVT_COMMAND_TEXT_ENTER));
37362     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_URL", PyInt_FromLong(wxEVT_COMMAND_TEXT_URL));
37363     PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_MAXLEN", PyInt_FromLong(wxEVT_COMMAND_TEXT_MAXLEN));
37364     SWIG_addvarlink(SWIG_globals,(char*)"ScrollBarNameStr",_wrap_ScrollBarNameStr_get, _wrap_ScrollBarNameStr_set);
37365     SWIG_addvarlink(SWIG_globals,(char*)"SPIN_BUTTON_NAME",_wrap_SPIN_BUTTON_NAME_get, _wrap_SPIN_BUTTON_NAME_set);
37366     SWIG_addvarlink(SWIG_globals,(char*)"SpinCtrlNameStr",_wrap_SpinCtrlNameStr_get, _wrap_SpinCtrlNameStr_set);
37367     {
37368         PyDict_SetItemString(d,"SP_HORIZONTAL", SWIG_From_int((int)(wxSP_HORIZONTAL)));
37369     }
37370     {
37371         PyDict_SetItemString(d,"SP_VERTICAL", SWIG_From_int((int)(wxSP_VERTICAL)));
37372     }
37373     {
37374         PyDict_SetItemString(d,"SP_ARROW_KEYS", SWIG_From_int((int)(wxSP_ARROW_KEYS)));
37375     }
37376     {
37377         PyDict_SetItemString(d,"SP_WRAP", SWIG_From_int((int)(wxSP_WRAP)));
37378     }
37379     PyDict_SetItemString(d, "wxEVT_COMMAND_SPINCTRL_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SPINCTRL_UPDATED));
37380     SWIG_addvarlink(SWIG_globals,(char*)"RadioBoxNameStr",_wrap_RadioBoxNameStr_get, _wrap_RadioBoxNameStr_set);
37381     SWIG_addvarlink(SWIG_globals,(char*)"RadioButtonNameStr",_wrap_RadioButtonNameStr_get, _wrap_RadioButtonNameStr_set);
37382     SWIG_addvarlink(SWIG_globals,(char*)"SliderNameStr",_wrap_SliderNameStr_get, _wrap_SliderNameStr_set);
37383     {
37384         PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
37385     }
37386     {
37387         PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
37388     }
37389     {
37390         PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
37391     }
37392     {
37393         PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
37394     }
37395     {
37396         PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
37397     }
37398     {
37399         PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
37400     }
37401     {
37402         PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
37403     }
37404     {
37405         PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
37406     }
37407     {
37408         PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
37409     }
37410     {
37411         PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
37412     }
37413     {
37414         PyDict_SetItemString(d,"SL_INVERSE", SWIG_From_int((int)(wxSL_INVERSE)));
37415     }
37416     SWIG_addvarlink(SWIG_globals,(char*)"ToggleButtonNameStr",_wrap_ToggleButtonNameStr_get, _wrap_ToggleButtonNameStr_set);
37417     PyDict_SetItemString(d, "wxEVT_COMMAND_TOGGLEBUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED));
37418     SWIG_addvarlink(SWIG_globals,(char*)"NotebookNameStr",_wrap_NotebookNameStr_get, _wrap_NotebookNameStr_set);
37419     {
37420         PyDict_SetItemString(d,"NB_FIXEDWIDTH", SWIG_From_int((int)(wxNB_FIXEDWIDTH)));
37421     }
37422     {
37423         PyDict_SetItemString(d,"NB_TOP", SWIG_From_int((int)(wxNB_TOP)));
37424     }
37425     {
37426         PyDict_SetItemString(d,"NB_LEFT", SWIG_From_int((int)(wxNB_LEFT)));
37427     }
37428     {
37429         PyDict_SetItemString(d,"NB_RIGHT", SWIG_From_int((int)(wxNB_RIGHT)));
37430     }
37431     {
37432         PyDict_SetItemString(d,"NB_BOTTOM", SWIG_From_int((int)(wxNB_BOTTOM)));
37433     }
37434     {
37435         PyDict_SetItemString(d,"NB_MULTILINE", SWIG_From_int((int)(wxNB_MULTILINE)));
37436     }
37437     {
37438         PyDict_SetItemString(d,"NB_NOPAGETHEME", SWIG_From_int((int)(wxNB_NOPAGETHEME)));
37439     }
37440     {
37441         PyDict_SetItemString(d,"NB_HITTEST_NOWHERE", SWIG_From_int((int)(wxNB_HITTEST_NOWHERE)));
37442     }
37443     {
37444         PyDict_SetItemString(d,"NB_HITTEST_ONICON", SWIG_From_int((int)(wxNB_HITTEST_ONICON)));
37445     }
37446     {
37447         PyDict_SetItemString(d,"NB_HITTEST_ONLABEL", SWIG_From_int((int)(wxNB_HITTEST_ONLABEL)));
37448     }
37449     {
37450         PyDict_SetItemString(d,"NB_HITTEST_ONITEM", SWIG_From_int((int)(wxNB_HITTEST_ONITEM)));
37451     }
37452     PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED));
37453     PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING));
37454     {
37455         PyDict_SetItemString(d,"LB_DEFAULT", SWIG_From_int((int)(wxLB_DEFAULT)));
37456     }
37457     {
37458         PyDict_SetItemString(d,"LB_TOP", SWIG_From_int((int)(wxLB_TOP)));
37459     }
37460     {
37461         PyDict_SetItemString(d,"LB_BOTTOM", SWIG_From_int((int)(wxLB_BOTTOM)));
37462     }
37463     {
37464         PyDict_SetItemString(d,"LB_LEFT", SWIG_From_int((int)(wxLB_LEFT)));
37465     }
37466     {
37467         PyDict_SetItemString(d,"LB_RIGHT", SWIG_From_int((int)(wxLB_RIGHT)));
37468     }
37469     {
37470         PyDict_SetItemString(d,"LB_ALIGN_MASK", SWIG_From_int((int)(wxLB_ALIGN_MASK)));
37471     }
37472     PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED));
37473     PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING));
37474     {
37475         PyDict_SetItemString(d,"CHB_DEFAULT", SWIG_From_int((int)(wxCHB_DEFAULT)));
37476     }
37477     {
37478         PyDict_SetItemString(d,"CHB_TOP", SWIG_From_int((int)(wxCHB_TOP)));
37479     }
37480     {
37481         PyDict_SetItemString(d,"CHB_BOTTOM", SWIG_From_int((int)(wxCHB_BOTTOM)));
37482     }
37483     {
37484         PyDict_SetItemString(d,"CHB_LEFT", SWIG_From_int((int)(wxCHB_LEFT)));
37485     }
37486     {
37487         PyDict_SetItemString(d,"CHB_RIGHT", SWIG_From_int((int)(wxCHB_RIGHT)));
37488     }
37489     {
37490         PyDict_SetItemString(d,"CHB_ALIGN_MASK", SWIG_From_int((int)(wxCHB_ALIGN_MASK)));
37491     }
37492     PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED));
37493     PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING));
37494     {
37495         PyDict_SetItemString(d,"TOOL_STYLE_BUTTON", SWIG_From_int((int)(wxTOOL_STYLE_BUTTON)));
37496     }
37497     {
37498         PyDict_SetItemString(d,"TOOL_STYLE_SEPARATOR", SWIG_From_int((int)(wxTOOL_STYLE_SEPARATOR)));
37499     }
37500     {
37501         PyDict_SetItemString(d,"TOOL_STYLE_CONTROL", SWIG_From_int((int)(wxTOOL_STYLE_CONTROL)));
37502     }
37503     {
37504         PyDict_SetItemString(d,"TB_HORIZONTAL", SWIG_From_int((int)(wxTB_HORIZONTAL)));
37505     }
37506     {
37507         PyDict_SetItemString(d,"TB_VERTICAL", SWIG_From_int((int)(wxTB_VERTICAL)));
37508     }
37509     {
37510         PyDict_SetItemString(d,"TB_3DBUTTONS", SWIG_From_int((int)(wxTB_3DBUTTONS)));
37511     }
37512     {
37513         PyDict_SetItemString(d,"TB_FLAT", SWIG_From_int((int)(wxTB_FLAT)));
37514     }
37515     {
37516         PyDict_SetItemString(d,"TB_DOCKABLE", SWIG_From_int((int)(wxTB_DOCKABLE)));
37517     }
37518     {
37519         PyDict_SetItemString(d,"TB_NOICONS", SWIG_From_int((int)(wxTB_NOICONS)));
37520     }
37521     {
37522         PyDict_SetItemString(d,"TB_TEXT", SWIG_From_int((int)(wxTB_TEXT)));
37523     }
37524     {
37525         PyDict_SetItemString(d,"TB_NODIVIDER", SWIG_From_int((int)(wxTB_NODIVIDER)));
37526     }
37527     {
37528         PyDict_SetItemString(d,"TB_NOALIGN", SWIG_From_int((int)(wxTB_NOALIGN)));
37529     }
37530     {
37531         PyDict_SetItemString(d,"TB_HORZ_LAYOUT", SWIG_From_int((int)(wxTB_HORZ_LAYOUT)));
37532     }
37533     {
37534         PyDict_SetItemString(d,"TB_HORZ_TEXT", SWIG_From_int((int)(wxTB_HORZ_TEXT)));
37535     }
37536     SWIG_addvarlink(SWIG_globals,(char*)"ListCtrlNameStr",_wrap_ListCtrlNameStr_get, _wrap_ListCtrlNameStr_set);
37537     {
37538         PyDict_SetItemString(d,"LC_VRULES", SWIG_From_int((int)(wxLC_VRULES)));
37539     }
37540     {
37541         PyDict_SetItemString(d,"LC_HRULES", SWIG_From_int((int)(wxLC_HRULES)));
37542     }
37543     {
37544         PyDict_SetItemString(d,"LC_ICON", SWIG_From_int((int)(wxLC_ICON)));
37545     }
37546     {
37547         PyDict_SetItemString(d,"LC_SMALL_ICON", SWIG_From_int((int)(wxLC_SMALL_ICON)));
37548     }
37549     {
37550         PyDict_SetItemString(d,"LC_LIST", SWIG_From_int((int)(wxLC_LIST)));
37551     }
37552     {
37553         PyDict_SetItemString(d,"LC_REPORT", SWIG_From_int((int)(wxLC_REPORT)));
37554     }
37555     {
37556         PyDict_SetItemString(d,"LC_ALIGN_TOP", SWIG_From_int((int)(wxLC_ALIGN_TOP)));
37557     }
37558     {
37559         PyDict_SetItemString(d,"LC_ALIGN_LEFT", SWIG_From_int((int)(wxLC_ALIGN_LEFT)));
37560     }
37561     {
37562         PyDict_SetItemString(d,"LC_AUTOARRANGE", SWIG_From_int((int)(wxLC_AUTOARRANGE)));
37563     }
37564     {
37565         PyDict_SetItemString(d,"LC_VIRTUAL", SWIG_From_int((int)(wxLC_VIRTUAL)));
37566     }
37567     {
37568         PyDict_SetItemString(d,"LC_EDIT_LABELS", SWIG_From_int((int)(wxLC_EDIT_LABELS)));
37569     }
37570     {
37571         PyDict_SetItemString(d,"LC_NO_HEADER", SWIG_From_int((int)(wxLC_NO_HEADER)));
37572     }
37573     {
37574         PyDict_SetItemString(d,"LC_NO_SORT_HEADER", SWIG_From_int((int)(wxLC_NO_SORT_HEADER)));
37575     }
37576     {
37577         PyDict_SetItemString(d,"LC_SINGLE_SEL", SWIG_From_int((int)(wxLC_SINGLE_SEL)));
37578     }
37579     {
37580         PyDict_SetItemString(d,"LC_SORT_ASCENDING", SWIG_From_int((int)(wxLC_SORT_ASCENDING)));
37581     }
37582     {
37583         PyDict_SetItemString(d,"LC_SORT_DESCENDING", SWIG_From_int((int)(wxLC_SORT_DESCENDING)));
37584     }
37585     {
37586         PyDict_SetItemString(d,"LC_MASK_TYPE", SWIG_From_int((int)(wxLC_MASK_TYPE)));
37587     }
37588     {
37589         PyDict_SetItemString(d,"LC_MASK_ALIGN", SWIG_From_int((int)(wxLC_MASK_ALIGN)));
37590     }
37591     {
37592         PyDict_SetItemString(d,"LC_MASK_SORT", SWIG_From_int((int)(wxLC_MASK_SORT)));
37593     }
37594     {
37595         PyDict_SetItemString(d,"LIST_MASK_STATE", SWIG_From_int((int)(wxLIST_MASK_STATE)));
37596     }
37597     {
37598         PyDict_SetItemString(d,"LIST_MASK_TEXT", SWIG_From_int((int)(wxLIST_MASK_TEXT)));
37599     }
37600     {
37601         PyDict_SetItemString(d,"LIST_MASK_IMAGE", SWIG_From_int((int)(wxLIST_MASK_IMAGE)));
37602     }
37603     {
37604         PyDict_SetItemString(d,"LIST_MASK_DATA", SWIG_From_int((int)(wxLIST_MASK_DATA)));
37605     }
37606     {
37607         PyDict_SetItemString(d,"LIST_SET_ITEM", SWIG_From_int((int)(wxLIST_SET_ITEM)));
37608     }
37609     {
37610         PyDict_SetItemString(d,"LIST_MASK_WIDTH", SWIG_From_int((int)(wxLIST_MASK_WIDTH)));
37611     }
37612     {
37613         PyDict_SetItemString(d,"LIST_MASK_FORMAT", SWIG_From_int((int)(wxLIST_MASK_FORMAT)));
37614     }
37615     {
37616         PyDict_SetItemString(d,"LIST_STATE_DONTCARE", SWIG_From_int((int)(wxLIST_STATE_DONTCARE)));
37617     }
37618     {
37619         PyDict_SetItemString(d,"LIST_STATE_DROPHILITED", SWIG_From_int((int)(wxLIST_STATE_DROPHILITED)));
37620     }
37621     {
37622         PyDict_SetItemString(d,"LIST_STATE_FOCUSED", SWIG_From_int((int)(wxLIST_STATE_FOCUSED)));
37623     }
37624     {
37625         PyDict_SetItemString(d,"LIST_STATE_SELECTED", SWIG_From_int((int)(wxLIST_STATE_SELECTED)));
37626     }
37627     {
37628         PyDict_SetItemString(d,"LIST_STATE_CUT", SWIG_From_int((int)(wxLIST_STATE_CUT)));
37629     }
37630     {
37631         PyDict_SetItemString(d,"LIST_STATE_DISABLED", SWIG_From_int((int)(wxLIST_STATE_DISABLED)));
37632     }
37633     {
37634         PyDict_SetItemString(d,"LIST_STATE_FILTERED", SWIG_From_int((int)(wxLIST_STATE_FILTERED)));
37635     }
37636     {
37637         PyDict_SetItemString(d,"LIST_STATE_INUSE", SWIG_From_int((int)(wxLIST_STATE_INUSE)));
37638     }
37639     {
37640         PyDict_SetItemString(d,"LIST_STATE_PICKED", SWIG_From_int((int)(wxLIST_STATE_PICKED)));
37641     }
37642     {
37643         PyDict_SetItemString(d,"LIST_STATE_SOURCE", SWIG_From_int((int)(wxLIST_STATE_SOURCE)));
37644     }
37645     {
37646         PyDict_SetItemString(d,"LIST_HITTEST_ABOVE", SWIG_From_int((int)(wxLIST_HITTEST_ABOVE)));
37647     }
37648     {
37649         PyDict_SetItemString(d,"LIST_HITTEST_BELOW", SWIG_From_int((int)(wxLIST_HITTEST_BELOW)));
37650     }
37651     {
37652         PyDict_SetItemString(d,"LIST_HITTEST_NOWHERE", SWIG_From_int((int)(wxLIST_HITTEST_NOWHERE)));
37653     }
37654     {
37655         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMICON", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMICON)));
37656     }
37657     {
37658         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMLABEL", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMLABEL)));
37659     }
37660     {
37661         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMRIGHT", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMRIGHT)));
37662     }
37663     {
37664         PyDict_SetItemString(d,"LIST_HITTEST_ONITEMSTATEICON", SWIG_From_int((int)(wxLIST_HITTEST_ONITEMSTATEICON)));
37665     }
37666     {
37667         PyDict_SetItemString(d,"LIST_HITTEST_TOLEFT", SWIG_From_int((int)(wxLIST_HITTEST_TOLEFT)));
37668     }
37669     {
37670         PyDict_SetItemString(d,"LIST_HITTEST_TORIGHT", SWIG_From_int((int)(wxLIST_HITTEST_TORIGHT)));
37671     }
37672     {
37673         PyDict_SetItemString(d,"LIST_HITTEST_ONITEM", SWIG_From_int((int)(wxLIST_HITTEST_ONITEM)));
37674     }
37675     {
37676         PyDict_SetItemString(d,"LIST_NEXT_ABOVE", SWIG_From_int((int)(wxLIST_NEXT_ABOVE)));
37677     }
37678     {
37679         PyDict_SetItemString(d,"LIST_NEXT_ALL", SWIG_From_int((int)(wxLIST_NEXT_ALL)));
37680     }
37681     {
37682         PyDict_SetItemString(d,"LIST_NEXT_BELOW", SWIG_From_int((int)(wxLIST_NEXT_BELOW)));
37683     }
37684     {
37685         PyDict_SetItemString(d,"LIST_NEXT_LEFT", SWIG_From_int((int)(wxLIST_NEXT_LEFT)));
37686     }
37687     {
37688         PyDict_SetItemString(d,"LIST_NEXT_RIGHT", SWIG_From_int((int)(wxLIST_NEXT_RIGHT)));
37689     }
37690     {
37691         PyDict_SetItemString(d,"LIST_ALIGN_DEFAULT", SWIG_From_int((int)(wxLIST_ALIGN_DEFAULT)));
37692     }
37693     {
37694         PyDict_SetItemString(d,"LIST_ALIGN_LEFT", SWIG_From_int((int)(wxLIST_ALIGN_LEFT)));
37695     }
37696     {
37697         PyDict_SetItemString(d,"LIST_ALIGN_TOP", SWIG_From_int((int)(wxLIST_ALIGN_TOP)));
37698     }
37699     {
37700         PyDict_SetItemString(d,"LIST_ALIGN_SNAP_TO_GRID", SWIG_From_int((int)(wxLIST_ALIGN_SNAP_TO_GRID)));
37701     }
37702     {
37703         PyDict_SetItemString(d,"LIST_FORMAT_LEFT", SWIG_From_int((int)(wxLIST_FORMAT_LEFT)));
37704     }
37705     {
37706         PyDict_SetItemString(d,"LIST_FORMAT_RIGHT", SWIG_From_int((int)(wxLIST_FORMAT_RIGHT)));
37707     }
37708     {
37709         PyDict_SetItemString(d,"LIST_FORMAT_CENTRE", SWIG_From_int((int)(wxLIST_FORMAT_CENTRE)));
37710     }
37711     {
37712         PyDict_SetItemString(d,"LIST_FORMAT_CENTER", SWIG_From_int((int)(wxLIST_FORMAT_CENTER)));
37713     }
37714     {
37715         PyDict_SetItemString(d,"LIST_AUTOSIZE", SWIG_From_int((int)(wxLIST_AUTOSIZE)));
37716     }
37717     {
37718         PyDict_SetItemString(d,"LIST_AUTOSIZE_USEHEADER", SWIG_From_int((int)(wxLIST_AUTOSIZE_USEHEADER)));
37719     }
37720     {
37721         PyDict_SetItemString(d,"LIST_RECT_BOUNDS", SWIG_From_int((int)(wxLIST_RECT_BOUNDS)));
37722     }
37723     {
37724         PyDict_SetItemString(d,"LIST_RECT_ICON", SWIG_From_int((int)(wxLIST_RECT_ICON)));
37725     }
37726     {
37727         PyDict_SetItemString(d,"LIST_RECT_LABEL", SWIG_From_int((int)(wxLIST_RECT_LABEL)));
37728     }
37729     {
37730         PyDict_SetItemString(d,"LIST_FIND_UP", SWIG_From_int((int)(wxLIST_FIND_UP)));
37731     }
37732     {
37733         PyDict_SetItemString(d,"LIST_FIND_DOWN", SWIG_From_int((int)(wxLIST_FIND_DOWN)));
37734     }
37735     {
37736         PyDict_SetItemString(d,"LIST_FIND_LEFT", SWIG_From_int((int)(wxLIST_FIND_LEFT)));
37737     }
37738     {
37739         PyDict_SetItemString(d,"LIST_FIND_RIGHT", SWIG_From_int((int)(wxLIST_FIND_RIGHT)));
37740     }
37741     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_DRAG));
37742     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_RDRAG));
37743     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT));
37744     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_END_LABEL_EDIT));
37745     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ITEM));
37746     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS));
37747     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_SELECTED));
37748     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_DESELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_DESELECTED));
37749     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_LIST_KEY_DOWN));
37750     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_INSERT_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_INSERT_ITEM));
37751     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_CLICK));
37752     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK));
37753     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK));
37754     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_ACTIVATED));
37755     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_CACHE_HINT", PyInt_FromLong(wxEVT_COMMAND_LIST_CACHE_HINT));
37756     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK));
37757     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG));
37758     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_DRAGGING", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_DRAGGING));
37759     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_END_DRAG));
37760     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_FOCUSED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_FOCUSED));
37761     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_GET_INFO", PyInt_FromLong(wxEVT_COMMAND_LIST_GET_INFO));
37762     PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_SET_INFO", PyInt_FromLong(wxEVT_COMMAND_LIST_SET_INFO));
37763
37764     // Map renamed classes back to their common name for OOR
37765     wxPyPtrTypeMap_Add("wxListCtrl", "wxPyListCtrl");
37766
37767     SWIG_addvarlink(SWIG_globals,(char*)"TreeCtrlNameStr",_wrap_TreeCtrlNameStr_get, _wrap_TreeCtrlNameStr_set);
37768     {
37769         PyDict_SetItemString(d,"TR_NO_BUTTONS", SWIG_From_int((int)(wxTR_NO_BUTTONS)));
37770     }
37771     {
37772         PyDict_SetItemString(d,"TR_HAS_BUTTONS", SWIG_From_int((int)(wxTR_HAS_BUTTONS)));
37773     }
37774     {
37775         PyDict_SetItemString(d,"TR_NO_LINES", SWIG_From_int((int)(wxTR_NO_LINES)));
37776     }
37777     {
37778         PyDict_SetItemString(d,"TR_LINES_AT_ROOT", SWIG_From_int((int)(wxTR_LINES_AT_ROOT)));
37779     }
37780     {
37781         PyDict_SetItemString(d,"TR_SINGLE", SWIG_From_int((int)(wxTR_SINGLE)));
37782     }
37783     {
37784         PyDict_SetItemString(d,"TR_MULTIPLE", SWIG_From_int((int)(wxTR_MULTIPLE)));
37785     }
37786     {
37787         PyDict_SetItemString(d,"TR_EXTENDED", SWIG_From_int((int)(wxTR_EXTENDED)));
37788     }
37789     {
37790         PyDict_SetItemString(d,"TR_HAS_VARIABLE_ROW_HEIGHT", SWIG_From_int((int)(wxTR_HAS_VARIABLE_ROW_HEIGHT)));
37791     }
37792     {
37793         PyDict_SetItemString(d,"TR_EDIT_LABELS", SWIG_From_int((int)(wxTR_EDIT_LABELS)));
37794     }
37795     {
37796         PyDict_SetItemString(d,"TR_HIDE_ROOT", SWIG_From_int((int)(wxTR_HIDE_ROOT)));
37797     }
37798     {
37799         PyDict_SetItemString(d,"TR_ROW_LINES", SWIG_From_int((int)(wxTR_ROW_LINES)));
37800     }
37801     {
37802         PyDict_SetItemString(d,"TR_FULL_ROW_HIGHLIGHT", SWIG_From_int((int)(wxTR_FULL_ROW_HIGHLIGHT)));
37803     }
37804     {
37805         PyDict_SetItemString(d,"TR_DEFAULT_STYLE", SWIG_From_int((int)(wxTR_DEFAULT_STYLE)));
37806     }
37807     {
37808         PyDict_SetItemString(d,"TR_TWIST_BUTTONS", SWIG_From_int((int)(wxTR_TWIST_BUTTONS)));
37809     }
37810     {
37811         PyDict_SetItemString(d,"TR_MAC_BUTTONS", SWIG_From_int((int)(wxTR_MAC_BUTTONS)));
37812     }
37813     {
37814         PyDict_SetItemString(d,"TR_AQUA_BUTTONS", SWIG_From_int((int)(wxTR_AQUA_BUTTONS)));
37815     }
37816     {
37817         PyDict_SetItemString(d,"TreeItemIcon_Normal", SWIG_From_int((int)(wxTreeItemIcon_Normal)));
37818     }
37819     {
37820         PyDict_SetItemString(d,"TreeItemIcon_Selected", SWIG_From_int((int)(wxTreeItemIcon_Selected)));
37821     }
37822     {
37823         PyDict_SetItemString(d,"TreeItemIcon_Expanded", SWIG_From_int((int)(wxTreeItemIcon_Expanded)));
37824     }
37825     {
37826         PyDict_SetItemString(d,"TreeItemIcon_SelectedExpanded", SWIG_From_int((int)(wxTreeItemIcon_SelectedExpanded)));
37827     }
37828     {
37829         PyDict_SetItemString(d,"TreeItemIcon_Max", SWIG_From_int((int)(wxTreeItemIcon_Max)));
37830     }
37831     {
37832         PyDict_SetItemString(d,"TREE_HITTEST_ABOVE", SWIG_From_int((int)(wxTREE_HITTEST_ABOVE)));
37833     }
37834     {
37835         PyDict_SetItemString(d,"TREE_HITTEST_BELOW", SWIG_From_int((int)(wxTREE_HITTEST_BELOW)));
37836     }
37837     {
37838         PyDict_SetItemString(d,"TREE_HITTEST_NOWHERE", SWIG_From_int((int)(wxTREE_HITTEST_NOWHERE)));
37839     }
37840     {
37841         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMBUTTON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMBUTTON)));
37842     }
37843     {
37844         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMICON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMICON)));
37845     }
37846     {
37847         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMINDENT", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMINDENT)));
37848     }
37849     {
37850         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMLABEL", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMLABEL)));
37851     }
37852     {
37853         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMRIGHT", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMRIGHT)));
37854     }
37855     {
37856         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMSTATEICON", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMSTATEICON)));
37857     }
37858     {
37859         PyDict_SetItemString(d,"TREE_HITTEST_TOLEFT", SWIG_From_int((int)(wxTREE_HITTEST_TOLEFT)));
37860     }
37861     {
37862         PyDict_SetItemString(d,"TREE_HITTEST_TORIGHT", SWIG_From_int((int)(wxTREE_HITTEST_TORIGHT)));
37863     }
37864     {
37865         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMUPPERPART", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMUPPERPART)));
37866     }
37867     {
37868         PyDict_SetItemString(d,"TREE_HITTEST_ONITEMLOWERPART", SWIG_From_int((int)(wxTREE_HITTEST_ONITEMLOWERPART)));
37869     }
37870     {
37871         PyDict_SetItemString(d,"TREE_HITTEST_ONITEM", SWIG_From_int((int)(wxTREE_HITTEST_ONITEM)));
37872     }
37873     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_DRAG));
37874     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_RDRAG));
37875     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT));
37876     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_END_LABEL_EDIT));
37877     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_TREE_DELETE_ITEM));
37878     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_GET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_GET_INFO));
37879     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_SET_INFO));
37880     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDED));
37881     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDING));
37882     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSED));
37883     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSING));
37884     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGED", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGED));
37885     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGING", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGING));
37886     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_TREE_KEY_DOWN));
37887     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_ACTIVATED));
37888     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK));
37889     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK));
37890     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_END_DRAG));
37891     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK));
37892     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP));
37893     PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MENU", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MENU));
37894
37895     // Map renamed classes back to their common name for OOR
37896     wxPyPtrTypeMap_Add("wxTreeItemData", "wxPyTreeItemData");
37897     wxPyPtrTypeMap_Add("wxTreeCtrl", "wxPyTreeCtrl");
37898
37899     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogDefaultFolderStr",_wrap_DirDialogDefaultFolderStr_get, _wrap_DirDialogDefaultFolderStr_set);
37900     {
37901         PyDict_SetItemString(d,"DIRCTRL_DIR_ONLY", SWIG_From_int((int)(wxDIRCTRL_DIR_ONLY)));
37902     }
37903     {
37904         PyDict_SetItemString(d,"DIRCTRL_SELECT_FIRST", SWIG_From_int((int)(wxDIRCTRL_SELECT_FIRST)));
37905     }
37906     {
37907         PyDict_SetItemString(d,"DIRCTRL_SHOW_FILTERS", SWIG_From_int((int)(wxDIRCTRL_SHOW_FILTERS)));
37908     }
37909     {
37910         PyDict_SetItemString(d,"DIRCTRL_3D_INTERNAL", SWIG_From_int((int)(wxDIRCTRL_3D_INTERNAL)));
37911     }
37912     {
37913         PyDict_SetItemString(d,"DIRCTRL_EDIT_LABELS", SWIG_From_int((int)(wxDIRCTRL_EDIT_LABELS)));
37914     }
37915     {
37916         PyDict_SetItemString(d,"FRAME_EX_CONTEXTHELP", SWIG_From_int((int)(wxFRAME_EX_CONTEXTHELP)));
37917     }
37918     {
37919         PyDict_SetItemString(d,"DIALOG_EX_CONTEXTHELP", SWIG_From_int((int)(wxDIALOG_EX_CONTEXTHELP)));
37920     }
37921     PyDict_SetItemString(d, "wxEVT_HELP", PyInt_FromLong(wxEVT_HELP));
37922     PyDict_SetItemString(d, "wxEVT_DETAILED_HELP", PyInt_FromLong(wxEVT_DETAILED_HELP));
37923
37924     wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage");
37925
37926 }
37927