wxPython/src/msw/_windows_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_wxQueryLayoutInfoEvent swig_types[0]
1342 #define  SWIGTYPE_p_wxPreviewFrame swig_types[1]
1343 #define  SWIGTYPE_p_wxPyPreviewFrame swig_types[2]
1344 #define  SWIGTYPE_p_wxPyPanel swig_types[3]
1345 #define  SWIGTYPE_p_wxMenu swig_types[4]
1346 #define  SWIGTYPE_p_wxFontData swig_types[5]
1347 #define  SWIGTYPE_p_wxEvent swig_types[6]
1348 #define  SWIGTYPE_p_wxPrintData swig_types[7]
1349 #define  SWIGTYPE_p_wxTaskBarIcon swig_types[8]
1350 #define  SWIGTYPE_p_wxPyTaskBarIcon swig_types[9]
1351 #define  SWIGTYPE_p_wxIconBundle swig_types[10]
1352 #define  SWIGTYPE_p_wxLayoutAlgorithm swig_types[11]
1353 #define  SWIGTYPE_p_wxFindDialogEvent swig_types[12]
1354 #define  SWIGTYPE_p_wxPreviewCanvas swig_types[13]
1355 #define  SWIGTYPE_p_wxFont swig_types[14]
1356 #define  SWIGTYPE_p_wxSplitterEvent swig_types[15]
1357 #define  SWIGTYPE_p_wxRegion swig_types[16]
1358 #define  SWIGTYPE_ptrdiff_t swig_types[17]
1359 #define  SWIGTYPE_std__ptrdiff_t swig_types[18]
1360 #define  SWIGTYPE_p_wxFindReplaceData swig_types[19]
1361 #define  SWIGTYPE_p_int swig_types[20]
1362 #define  SWIGTYPE_p_wxSize swig_types[21]
1363 #define  SWIGTYPE_p_wxDC swig_types[22]
1364 #define  SWIGTYPE_p_wxIcon swig_types[23]
1365 #define  SWIGTYPE_p_wxVisualAttributes swig_types[24]
1366 #define  SWIGTYPE_p_wxMDIChildFrame swig_types[25]
1367 #define  SWIGTYPE_p_wxColourData swig_types[26]
1368 #define  SWIGTYPE_p_wxNotifyEvent swig_types[27]
1369 #define  SWIGTYPE_p_wxPyWindow swig_types[28]
1370 #define  SWIGTYPE_p_form_ops_t swig_types[29]
1371 #define  SWIGTYPE_p_wxSplashScreen swig_types[30]
1372 #define  SWIGTYPE_p_wxPasswordEntryDialog swig_types[31]
1373 #define  SWIGTYPE_p_wxSingleChoiceDialog swig_types[32]
1374 #define  SWIGTYPE_p_wxMultiChoiceDialog swig_types[33]
1375 #define  SWIGTYPE_p_wxFileDialog swig_types[34]
1376 #define  SWIGTYPE_p_wxTextEntryDialog swig_types[35]
1377 #define  SWIGTYPE_p_wxMessageDialog swig_types[36]
1378 #define  SWIGTYPE_p_wxProgressDialog swig_types[37]
1379 #define  SWIGTYPE_p_wxFindReplaceDialog swig_types[38]
1380 #define  SWIGTYPE_p_wxPrinter swig_types[39]
1381 #define  SWIGTYPE_p_wxArrayInt swig_types[40]
1382 #define  SWIGTYPE_p_wxDuplexMode swig_types[41]
1383 #define  SWIGTYPE_p_wxEvtHandler swig_types[42]
1384 #define  SWIGTYPE_p_wxCalculateLayoutEvent swig_types[43]
1385 #define  SWIGTYPE_p_wxPyHtmlListBox swig_types[44]
1386 #define  SWIGTYPE_p_wxPyVListBox swig_types[45]
1387 #define  SWIGTYPE_p_wxRect swig_types[46]
1388 #define  SWIGTYPE_p_wxStdDialogButtonSizer swig_types[47]
1389 #define  SWIGTYPE_p_char swig_types[48]
1390 #define  SWIGTYPE_p_wxMiniFrame swig_types[49]
1391 #define  SWIGTYPE_p_wxFrame swig_types[50]
1392 #define  SWIGTYPE_p_wxPyPrintout swig_types[51]
1393 #define  SWIGTYPE_p_wxTaskBarIconEvent swig_types[52]
1394 #define  SWIGTYPE_p_wxScrollWinEvent swig_types[53]
1395 #define  SWIGTYPE_p_wxPaperSize swig_types[54]
1396 #define  SWIGTYPE_p_wxStatusBar swig_types[55]
1397 #define  SWIGTYPE_p_wxMDIParentFrame swig_types[56]
1398 #define  SWIGTYPE_p_wxPoint swig_types[57]
1399 #define  SWIGTYPE_p_wxObject swig_types[58]
1400 #define  SWIGTYPE_p_unsigned_long swig_types[59]
1401 #define  SWIGTYPE_p_wxTipWindow swig_types[60]
1402 #define  SWIGTYPE_p_wxSashLayoutWindow swig_types[61]
1403 #define  SWIGTYPE_p_wxSplitterWindow swig_types[62]
1404 #define  SWIGTYPE_p_wxSplashScreenWindow swig_types[63]
1405 #define  SWIGTYPE_p_wxPyVScrolledWindow swig_types[64]
1406 #define  SWIGTYPE_p_wxPyPopupTransientWindow swig_types[65]
1407 #define  SWIGTYPE_p_wxPopupWindow swig_types[66]
1408 #define  SWIGTYPE_p_wxSashWindow swig_types[67]
1409 #define  SWIGTYPE_p_wxTopLevelWindow swig_types[68]
1410 #define  SWIGTYPE_p_wxWindow swig_types[69]
1411 #define  SWIGTYPE_p_wxScrolledWindow swig_types[70]
1412 #define  SWIGTYPE_p_wxMenuBar swig_types[71]
1413 #define  SWIGTYPE_p_wxMDIClientWindow swig_types[72]
1414 #define  SWIGTYPE_p_wxPyScrolledWindow swig_types[73]
1415 #define  SWIGTYPE_p_wxPrintPreview swig_types[74]
1416 #define  SWIGTYPE_p_wxSashEvent swig_types[75]
1417 #define  SWIGTYPE_p_wxString swig_types[76]
1418 #define  SWIGTYPE_p_wxPyPrintPreview swig_types[77]
1419 #define  SWIGTYPE_p_wxDirDialog swig_types[78]
1420 #define  SWIGTYPE_p_wxColourDialog swig_types[79]
1421 #define  SWIGTYPE_p_wxDialog swig_types[80]
1422 #define  SWIGTYPE_p_wxPanel swig_types[81]
1423 #define  SWIGTYPE_p_wxFontDialog swig_types[82]
1424 #define  SWIGTYPE_p_wxPageSetupDialog swig_types[83]
1425 #define  SWIGTYPE_p_wxPrintDialog swig_types[84]
1426 #define  SWIGTYPE_p_wxFileSystem swig_types[85]
1427 #define  SWIGTYPE_p_wxBitmap swig_types[86]
1428 #define  SWIGTYPE_unsigned_int swig_types[87]
1429 #define  SWIGTYPE_p_unsigned_int swig_types[88]
1430 #define  SWIGTYPE_p_unsigned_char swig_types[89]
1431 #define  SWIGTYPE_p_wxCommandEvent swig_types[90]
1432 #define  SWIGTYPE_p_wxPreviewControlBar swig_types[91]
1433 #define  SWIGTYPE_p_wxPyPreviewControlBar swig_types[92]
1434 #define  SWIGTYPE_p_wxColour swig_types[93]
1435 #define  SWIGTYPE_p_wxToolBar swig_types[94]
1436 #define  SWIGTYPE_p_wxPageSetupDialogData swig_types[95]
1437 #define  SWIGTYPE_p_wxPrintDialogData swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444               @(target):= _windows_.so
1445   ------------------------------------------------*/
1446 #define SWIG_init    init_windows_
1447
1448 #define SWIG_name    "_windows_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452
1453
1454  static const wxString wxPyEmptyString(wxEmptyString);
1455  static const wxString wxPyPanelNameStr(wxPanelNameStr);
1456
1457
1458
1459 #include <limits.h>
1460
1461
1462 SWIGINTERN int
1463   SWIG_CheckLongInRange(long value, long min_value, long max_value,
1464                         const char *errmsg)
1465 {
1466   if (value < min_value) {
1467     if (errmsg) {
1468       PyErr_Format(PyExc_OverflowError,
1469                    "value %ld is less than '%s' minimum %ld",
1470                    value, errmsg, min_value);
1471     }
1472     return 0;
1473   } else if (value > max_value) {
1474     if (errmsg) {
1475       PyErr_Format(PyExc_OverflowError,
1476                    "value %ld is greater than '%s' maximum %ld",
1477                    value, errmsg, max_value);
1478     }
1479     return 0;
1480   }
1481   return 1;
1482 }
1483
1484
1485 SWIGINTERN int
1486 SWIG_AsVal_long(PyObject* obj, long* val)
1487 {
1488     if (PyNumber_Check(obj)) {
1489         if (val) *val = PyInt_AsLong(obj);
1490         return 1;
1491     }
1492     else {
1493         SWIG_type_error("number", obj);
1494     }
1495     return 0;
1496 }
1497
1498
1499 #if INT_MAX != LONG_MAX
1500 SWIGINTERN int
1501   SWIG_AsVal_int(PyObject *obj, int *val)
1502 {
1503   const char* errmsg = val ? "int" : (char*)0;
1504   long v;
1505   if (SWIG_AsVal_long(obj, &v)) {
1506     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1507       if (val) *val = (int)(v);
1508       return 1;
1509     } else {
1510       return 0;
1511     }
1512   } else {
1513     PyErr_Clear();
1514   }
1515   if (val) {
1516     SWIG_type_error(errmsg, obj);
1517   }
1518   return 0;
1519 }
1520 #else
1521 SWIGINTERNSHORT int
1522   SWIG_AsVal_int(PyObject *obj, int *val)
1523 {
1524   return SWIG_AsVal_long(obj,(long*)val);
1525 }
1526 #endif
1527
1528
1529 SWIGINTERNSHORT int
1530 SWIG_As_int(PyObject* obj)
1531 {
1532   int v;
1533   if (!SWIG_AsVal_int(obj, &v)) {
1534     /*
1535       this is needed to make valgrind/purify happier.
1536      */
1537     memset((void*)&v, 0, sizeof(int));
1538   }
1539   return v;
1540 }
1541
1542
1543 SWIGINTERNSHORT long
1544 SWIG_As_long(PyObject* obj)
1545 {
1546   long v;
1547   if (!SWIG_AsVal_long(obj, &v)) {
1548     /*
1549       this is needed to make valgrind/purify happier.
1550      */
1551     memset((void*)&v, 0, sizeof(long));
1552   }
1553   return v;
1554 }
1555
1556
1557 SWIGINTERNSHORT int
1558 SWIG_Check_int(PyObject* obj)
1559 {
1560   return SWIG_AsVal_int(obj, (int*)0);
1561 }
1562
1563
1564 SWIGINTERNSHORT int
1565 SWIG_Check_long(PyObject* obj)
1566 {
1567   return SWIG_AsVal_long(obj, (long*)0);
1568 }
1569
1570
1571 SWIGINTERN int
1572   SWIG_AsVal_bool(PyObject *obj, bool *val)
1573 {
1574   if (obj == Py_True) {
1575     if (val) *val = true;
1576     return 1;
1577   }
1578   if (obj == Py_False) {
1579     if (val) *val = false;
1580     return 1;
1581   }
1582   int res = 0;
1583   if (SWIG_AsVal_int(obj, &res)) {
1584     if (val) *val = res ? true : false;
1585     return 1;
1586   } else {
1587     PyErr_Clear();
1588   }
1589   if (val) {
1590     SWIG_type_error("bool", obj);
1591   }
1592   return 0;
1593 }
1594
1595
1596 SWIGINTERNSHORT bool
1597 SWIG_As_bool(PyObject* obj)
1598 {
1599   bool v;
1600   if (!SWIG_AsVal_bool(obj, &v)) {
1601     /*
1602       this is needed to make valgrind/purify happier.
1603      */
1604     memset((void*)&v, 0, sizeof(bool));
1605   }
1606   return v;
1607 }
1608
1609
1610 SWIGINTERNSHORT int
1611 SWIG_Check_bool(PyObject* obj)
1612 {
1613   return SWIG_AsVal_bool(obj, (bool*)0);
1614 }
1615
1616
1617   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1618 #define SWIG_From_int PyInt_FromLong
1619 /*@@*/
1620
1621
1622   static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1623     PyObject*   o2;
1624     PyObject*   o3;
1625
1626     if (!target) {
1627         target = o;
1628     } else if (target == Py_None) {
1629         Py_DECREF(Py_None);
1630         target = o;
1631     } else {
1632         if (!PyTuple_Check(target)) {
1633             o2 = target;
1634             target = PyTuple_New(1);
1635             PyTuple_SetItem(target, 0, o2);
1636         }
1637         o3 = PyTuple_New(1);
1638         PyTuple_SetItem(o3, 0, o);
1639
1640         o2 = target;
1641         target = PySequence_Concat(o2, o3);
1642         Py_DECREF(o2);
1643         Py_DECREF(o3);
1644     }
1645     return target;
1646   }
1647
1648
1649
1650 SWIGINTERN int
1651 SWIG_AsVal_double(PyObject *obj, double* val)
1652 {
1653     if (PyNumber_Check(obj)) {
1654         if (val) *val = PyFloat_AsDouble(obj);
1655         return 1;
1656     }
1657     else {
1658         SWIG_type_error("number", obj);
1659     }
1660     return 0;
1661 }
1662
1663
1664 SWIGINTERNSHORT double
1665 SWIG_As_double(PyObject* obj)
1666 {
1667   double v;
1668   if (!SWIG_AsVal_double(obj, &v)) {
1669     /*
1670       this is needed to make valgrind/purify happier.
1671      */
1672     memset((void*)&v, 0, sizeof(double));
1673   }
1674   return v;
1675 }
1676
1677
1678 SWIGINTERNSHORT int
1679 SWIG_Check_double(PyObject* obj)
1680 {
1681   return SWIG_AsVal_double(obj, (double*)0);
1682 }
1683
1684
1685   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1686 #define SWIG_From_double PyFloat_FromDouble
1687 /*@@*/
1688
1689  static const wxString wxPyFrameNameStr(wxFrameNameStr);
1690  static const wxString wxPyDialogNameStr(wxDialogNameStr);
1691  static const wxString wxPyStatusLineNameStr(wxStatusLineNameStr);
1692  static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
1693 static void wxTopLevelWindow_MacSetMetalAppearance(wxTopLevelWindow *self,bool on){ /*wxPyRaiseNotImplemented();*/ }
1694 static bool wxTopLevelWindow_MacGetMetalAppearance(wxTopLevelWindow const *self){ /*wxPyRaiseNotImplemented();*/ return false; }
1695
1696   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1697 #define SWIG_From_long PyInt_FromLong
1698 /*@@*/
1699
1700
1701
1702 static wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
1703             wxRect r;
1704             self->GetFieldRect(i, r);
1705             return r;
1706         }
1707  static const wxString wxPySplitterNameStr(wxT("splitter"));
1708  static const wxString wxPySashNameStr(wxT("sashWindow"));
1709  static const wxString wxPySashLayoutNameStr(wxT("layoutWindow"));
1710
1711 #include <wx/popupwin.h>
1712
1713
1714 class wxPyPopupTransientWindow : public wxPopupTransientWindow
1715 {
1716 public:
1717     wxPyPopupTransientWindow() : wxPopupTransientWindow() {}
1718     wxPyPopupTransientWindow(wxWindow* parent, int style = wxBORDER_NONE)
1719         : wxPopupTransientWindow(parent, style) {}
1720
1721     DEC_PYCALLBACK_BOOL_ME(ProcessLeftDown);
1722     DEC_PYCALLBACK__(OnDismiss);
1723     DEC_PYCALLBACK_BOOL_(CanDismiss);
1724     PYPRIVATE;
1725 };
1726
1727
1728 IMP_PYCALLBACK_BOOL_ME(wxPyPopupTransientWindow, wxPopupTransientWindow, ProcessLeftDown);
1729 IMP_PYCALLBACK__(wxPyPopupTransientWindow, wxPopupTransientWindow, OnDismiss);
1730 IMP_PYCALLBACK_BOOL_(wxPyPopupTransientWindow, wxPopupTransientWindow, CanDismiss);
1731
1732
1733 #include <wx/tipwin.h>
1734
1735 static wxTipWindow *new_wxTipWindow(wxWindow *parent,wxString const &text,int maxLength=100,wxRect *rectBound=NULL){
1736             return new wxTipWindow(parent, text, maxLength, NULL, rectBound);
1737         }
1738
1739 #include <wx/tipwin.h>
1740
1741
1742 #include <wx/vscroll.h>
1743
1744
1745 class wxPyVScrolledWindow  : public wxVScrolledWindow
1746 {
1747     DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow);
1748 public:
1749     wxPyVScrolledWindow() : wxVScrolledWindow() {}
1750
1751     wxPyVScrolledWindow(wxWindow *parent,
1752                         wxWindowID id = wxID_ANY,
1753                         const wxPoint& pos = wxDefaultPosition,
1754                         const wxSize& size = wxDefaultSize,
1755                         long style = 0,
1756                         const wxString& name = wxPyPanelNameStr)
1757         : wxVScrolledWindow(parent, id, pos, size, style, name)
1758     {}
1759
1760     // Overridable virtuals
1761
1762     // this function must be overridden in the derived class and it should
1763     // return the height of the given line in pixels
1764     DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetLineHeight);
1765
1766
1767     // this function doesn't have to be overridden but it may be useful to do
1768     // it if calculating the lines heights is a relatively expensive operation
1769     // as it gives the user code a possibility to calculate several of them at
1770     // once
1771     //
1772     // OnGetLinesHint() is normally called just before OnGetLineHeight() but you
1773     // shouldn't rely on the latter being called for all lines in the interval
1774     // specified here. It is also possible that OnGetLineHeight() will be
1775     // called for the lines outside of this interval, so this is really just a
1776     // hint, not a promise.
1777     //
1778     // finally note that lineMin is inclusive, while lineMax is exclusive, as
1779     // usual
1780     DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetLinesHint);
1781
1782
1783     // when the number of lines changes, we try to estimate the total height
1784     // of all lines which is a rather expensive operation in terms of lines
1785     // access, so if the user code may estimate the average height
1786     // better/faster than we do, it should override this function to implement
1787     // its own logic
1788     //
1789     // this function should return the best guess for the total height it may
1790     // make
1791     DEC_PYCALLBACK_COORD_const(EstimateTotalHeight);
1792
1793
1794     // Also expose some other interesting protected methods
1795
1796
1797     // find the index of the line we need to show at the top of the window such
1798     // that the last (fully or partially) visible line is the given one
1799     size_t FindFirstFromBottom(size_t lineLast, bool fullyVisible = false)
1800     { return wxVScrolledWindow::FindFirstFromBottom(lineLast, fullyVisible); }
1801
1802     // get the total height of the lines between lineMin (inclusive) and
1803     // lineMax (exclusive)
1804     wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const
1805     { return wxVScrolledWindow::GetLinesHeight(lineMin, lineMax); }
1806
1807
1808     PYPRIVATE;
1809 };
1810
1811 IMPLEMENT_ABSTRACT_CLASS(wxPyVScrolledWindow, wxVScrolledWindow);
1812
1813 IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLineHeight);
1814 IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLinesHint);
1815 IMP_PYCALLBACK_COORD_const          (wxPyVScrolledWindow, wxVScrolledWindow, EstimateTotalHeight);
1816
1817
1818 SWIGINTERN int
1819 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1820 {
1821     long v = 0;
1822     if (SWIG_AsVal_long(obj, &v) && v < 0) {
1823         SWIG_type_error("unsigned number", obj);
1824     }
1825     else if (val)
1826         *val = (unsigned long)v;
1827     return 1;
1828 }
1829
1830
1831 SWIGINTERNSHORT unsigned long
1832 SWIG_As_unsigned_SS_long(PyObject* obj)
1833 {
1834   unsigned long v;
1835   if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1836     /*
1837       this is needed to make valgrind/purify happier.
1838      */
1839     memset((void*)&v, 0, sizeof(unsigned long));
1840   }
1841   return v;
1842 }
1843
1844
1845 SWIGINTERNSHORT int
1846 SWIG_Check_unsigned_SS_long(PyObject* obj)
1847 {
1848   return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1849 }
1850
1851
1852 SWIGINTERNSHORT PyObject*
1853   SWIG_From_unsigned_SS_long(unsigned long value)
1854 {
1855   return (value > LONG_MAX) ?
1856     PyLong_FromUnsignedLong(value)
1857     : PyInt_FromLong((long)(value));
1858 }
1859
1860
1861 #include <wx/vlbox.h>
1862
1863  static const wxString wxPyVListBoxNameStr(wxVListBoxNameStr);
1864
1865 class wxPyVListBox  : public wxVListBox
1866 {
1867     DECLARE_ABSTRACT_CLASS(wxPyVListBox);
1868 public:
1869     wxPyVListBox() : wxVListBox() {}
1870
1871     wxPyVListBox(wxWindow *parent,
1872                  wxWindowID id = wxID_ANY,
1873                  const wxPoint& pos = wxDefaultPosition,
1874                  const wxSize& size = wxDefaultSize,
1875                  long style = 0,
1876                  const wxString& name = wxPyVListBoxNameStr)
1877         : wxVListBox(parent, id, pos, size, style, name)
1878     {}
1879
1880     // Overridable virtuals
1881
1882     // the derived class must implement this function to actually draw the item
1883     // with the given index on the provided DC
1884     // virtual void OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const = 0;
1885     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawItem);
1886
1887
1888     // the derived class must implement this method to return the height of the
1889     // specified item
1890     // virtual wxCoord OnMeasureItem(size_t n) const = 0;
1891     DEC_PYCALLBACK_COORD_SIZET_constpure(OnMeasureItem);
1892
1893
1894     // this method may be used to draw separators between the lines; note that
1895     // the rectangle may be modified, typically to deflate it a bit before
1896     // passing to OnDrawItem()
1897     //
1898     // the base class version doesn't do anything
1899     //    virtual void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const;
1900     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawSeparator);
1901
1902
1903     // this method is used to draw the items background and, maybe, a border
1904     // around it
1905     //
1906     // the base class version implements a reasonable default behaviour which
1907     // consists in drawing the selected item with the standard background
1908     // colour and drawing a border around the item if it is either selected or
1909     // current
1910     //     virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const;
1911     DEC_PYCALLBACK__DCRECTSIZET_const(OnDrawBackground);
1912
1913
1914     PYPRIVATE;
1915 };
1916
1917 IMPLEMENT_ABSTRACT_CLASS(wxPyVListBox, wxVListBox);
1918
1919 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawItem);
1920 IMP_PYCALLBACK_COORD_SIZET_constpure (wxPyVListBox, wxVListBox, OnMeasureItem);
1921 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawSeparator);
1922 IMP_PYCALLBACK__DCRECTSIZET_const    (wxPyVListBox, wxVListBox, OnDrawBackground);
1923
1924
1925 static PyObject *wxPyVListBox_GetFirstSelected(wxPyVListBox *self){
1926             unsigned long cookie = 0;
1927             int selected = self->GetFirstSelected(cookie);
1928             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1929             PyObject* tup = PyTuple_New(2);
1930             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1931             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1932             wxPyEndBlockThreads(blocked);
1933             return tup;
1934         }
1935 static PyObject *wxPyVListBox_GetNextSelected(wxPyVListBox *self,unsigned long cookie){
1936             int selected = self->GetNextSelected(cookie);
1937             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1938             PyObject* tup = PyTuple_New(2);
1939             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1940             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1941             wxPyEndBlockThreads(blocked);
1942             return tup;
1943         }
1944
1945 #include <wx/htmllbox.h>
1946
1947
1948 class wxPyHtmlListBox  : public wxHtmlListBox
1949 {
1950     DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox);
1951 public:
1952     wxPyHtmlListBox() : wxHtmlListBox() {}
1953
1954     wxPyHtmlListBox(wxWindow *parent,
1955                     wxWindowID id = wxID_ANY,
1956                     const wxPoint& pos = wxDefaultPosition,
1957                     const wxSize& size = wxDefaultSize,
1958                     long style = 0,
1959                     const wxString& name = wxPyVListBoxNameStr)
1960         : wxHtmlListBox(parent, id, pos, size, style, name)
1961     {}
1962
1963     // Overridable virtuals
1964
1965     // this method must be implemented in the derived class and should return
1966     // the body (i.e. without <html>) of the HTML for the given item
1967     DEC_PYCALLBACK_STRING_SIZET_pure(OnGetItem);
1968
1969     // this function may be overridden to decorate HTML returned by OnGetItem()
1970     DEC_PYCALLBACK_STRING_SIZET(OnGetItemMarkup);
1971
1972 // TODO:
1973 //     // this method allows to customize the selection appearance: it may be used
1974 //     // to specify the colour of the text which normally has the given colour
1975 //     // colFg when it is inside the selection
1976 //     //
1977 //     // by default, the original colour is not used at all and all text has the
1978 //     // same (default for this system) colour inside selection
1979 //     virtual wxColour GetSelectedTextColour(const wxColour& colFg) const;
1980
1981 //     // this is the same as GetSelectedTextColour() but allows to customize the
1982 //     // background colour -- this is even more rarely used as you can change it
1983 //     // globally using SetSelectionBackground()
1984 //     virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const;
1985
1986
1987     PYPRIVATE;
1988 };
1989
1990
1991 IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlListBox, wxHtmlListBox)
1992
1993 IMP_PYCALLBACK_STRING_SIZET_pure(wxPyHtmlListBox, wxHtmlListBox, OnGetItem);
1994 IMP_PYCALLBACK_STRING_SIZET     (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup);
1995
1996
1997
1998
1999
2000 #ifndef wxHAS_TASK_BAR_ICON
2001 // implement dummy classes for platforms that don't have it
2002
2003 class wxTaskBarIcon : public wxEvtHandler
2004 {
2005 public:
2006     wxTaskBarIcon()  { wxPyRaiseNotImplemented(); }
2007 };
2008
2009
2010 class wxTaskBarIconEvent : public wxEvent
2011 {
2012 public:
2013     wxTaskBarIconEvent(wxEventType, wxTaskBarIcon *)
2014         { wxPyRaiseNotImplemented(); }
2015     virtual wxEvent* Clone() const { return NULL; }
2016     bool IsOk() const { return false; }
2017     bool IsIconInstalled() const { return false; }
2018     bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString) { return false; }
2019     bool RemoveIcon() { return false; }
2020     bool PopupMenu(wxMenu *menu) { return false; }
2021 };
2022
2023 enum {
2024     wxEVT_TASKBAR_MOVE = 0,
2025     wxEVT_TASKBAR_LEFT_DOWN = 0,
2026     wxEVT_TASKBAR_LEFT_UP = 0,
2027     wxEVT_TASKBAR_RIGHT_DOWN = 0,
2028     wxEVT_TASKBAR_RIGHT_UP = 0,
2029     wxEVT_TASKBAR_LEFT_DCLICK = 0,
2030     wxEVT_TASKBAR_RIGHT_DCLICK = 0,
2031 };
2032
2033
2034 #else
2035 // Otherwise make a class that can virtualize CreatePopupMenu
2036 class wxPyTaskBarIcon : public wxTaskBarIcon
2037 {
2038     DECLARE_ABSTRACT_CLASS(wxPyTaskBarIcon);
2039 public:
2040     wxPyTaskBarIcon() : wxTaskBarIcon()
2041     {}
2042
2043     wxMenu* CreatePopupMenu() {
2044         wxMenu *rval = NULL;
2045         bool found;
2046         wxPyBlock_t blocked = wxPyBeginBlockThreads();
2047         if ((found = wxPyCBH_findCallback(m_myInst, "CreatePopupMenu"))) {
2048             PyObject* ro;
2049             wxMenu* ptr;
2050             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2051             if (ro) {
2052                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxMenu")))
2053                     rval = ptr;
2054                 Py_DECREF(ro);
2055             }
2056         }
2057         wxPyEndBlockThreads(blocked);
2058         if (! found)
2059             rval = wxTaskBarIcon::CreatePopupMenu();
2060         return rval;
2061     }
2062
2063     PYPRIVATE;
2064 };
2065
2066 IMPLEMENT_ABSTRACT_CLASS(wxPyTaskBarIcon, wxTaskBarIcon);
2067
2068 #endif
2069
2070 static void wxPyTaskBarIcon_Destroy(wxPyTaskBarIcon *self){
2071             self->RemoveIcon();
2072             delete self;
2073         }
2074  static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2075  static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2076  static const wxString wxPyDirDialogNameStr(wxDirDialogNameStr);
2077  static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2078  static const wxString wxPyGetTextFromUserPromptStr(wxGetTextFromUserPromptStr);
2079  static const wxString wxPyMessageBoxCaptionStr(wxMessageBoxCaptionStr);
2080 static PyObject *wxFileDialog_GetFilenames(wxFileDialog *self){
2081             wxArrayString arr;
2082             self->GetFilenames(arr);
2083             return wxArrayString2PyList_helper(arr);
2084         }
2085 static PyObject *wxFileDialog_GetPaths(wxFileDialog *self){
2086             wxArrayString arr;
2087             self->GetPaths(arr);
2088             return wxArrayString2PyList_helper(arr);
2089         }
2090 static PyObject *wxMultiChoiceDialog_GetSelections(wxMultiChoiceDialog *self){
2091             return wxArrayInt2PyList_helper(self->GetSelections());
2092         }
2093 static wxSingleChoiceDialog *new_wxSingleChoiceDialog(wxWindow *parent,wxString const &message,wxString const &caption,int choices,wxString *choices_array,long style=wxCHOICEDLG_STYLE,wxPoint const &pos=wxDefaultPosition){
2094             return new wxSingleChoiceDialog(parent, message, caption,
2095                                             choices, choices_array, NULL, style, pos);
2096         }
2097  static const wxString wxPyGetPasswordFromUserPromptStr(wxGetPasswordFromUserPromptStr);
2098
2099 #include <wx/mdi.h>
2100
2101  // C++ version of Python aware wxWindow
2102 class wxPyWindow : public wxWindow
2103 {
2104     DECLARE_DYNAMIC_CLASS(wxPyWindow)
2105 public:
2106     wxPyWindow() : wxWindow() {}
2107     wxPyWindow(wxWindow* parent, const wxWindowID id,
2108                const wxPoint& pos = wxDefaultPosition,
2109                const wxSize& size = wxDefaultSize,
2110                long style = 0,
2111                const wxString& name = wxPyPanelNameStr)
2112         : wxWindow(parent, id, pos, size, style, name) {}
2113
2114     void SetBestSize(const wxSize& size) { wxWindow::SetBestSize(size); }
2115
2116     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2117     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2118     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2119     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2120
2121     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2122     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2123     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2124
2125     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2126     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2127
2128     DEC_PYCALLBACK__(InitDialog);
2129     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2130     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2131     DEC_PYCALLBACK_BOOL_(Validate);
2132
2133     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2134     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2135     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2136
2137     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2138     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2139
2140     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2141     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2142     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2143
2144     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2145
2146     PYPRIVATE;
2147 };
2148
2149 IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);
2150
2151 IMP_PYCALLBACK_VOID_INT4(wxPyWindow, wxWindow, DoMoveWindow);
2152 IMP_PYCALLBACK_VOID_INT5(wxPyWindow, wxWindow, DoSetSize);
2153 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetClientSize);
2154 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetVirtualSize);
2155
2156 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetSize);
2157 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetClientSize);
2158 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetPosition);
2159
2160 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
2161 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);
2162
2163 IMP_PYCALLBACK__(wxPyWindow, wxWindow, InitDialog);
2164 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataFromWindow);
2165 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataToWindow);
2166 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, Validate);
2167
2168 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocus);
2169 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocusFromKeyboard);
2170 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, GetMaxSize);
2171
2172 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, AddChild);
2173 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, RemoveChild);
2174
2175 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, ShouldInheritColours);
2176 IMP_PYCALLBACK__COLOUR(wxPyWindow, wxWindow, ApplyParentThemeBackground);
2177 IMP_PYCALLBACK_VIZATTR_(wxPyWindow, wxWindow, GetDefaultAttributes);
2178
2179 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, HasTransparentBackground);
2180
2181  // C++ version of Python aware wxPanel
2182 class wxPyPanel : public wxPanel
2183 {
2184     DECLARE_DYNAMIC_CLASS(wxPyPanel)
2185 public:
2186     wxPyPanel() : wxPanel() {}
2187     wxPyPanel(wxWindow* parent, const wxWindowID id,
2188                const wxPoint& pos = wxDefaultPosition,
2189                const wxSize& size = wxDefaultSize,
2190                long style = 0,
2191                const wxString& name = wxPyPanelNameStr)
2192         : wxPanel(parent, id, pos, size, style, name) {}
2193
2194     void SetBestSize(const wxSize& size) { wxPanel::SetBestSize(size); }
2195
2196
2197     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2198     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2199     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2200     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2201
2202     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2203     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2204     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2205
2206     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2207     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2208
2209     DEC_PYCALLBACK__(InitDialog);
2210     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2211     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2212     DEC_PYCALLBACK_BOOL_(Validate);
2213
2214     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2215     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2216     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2217
2218     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2219     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2220
2221     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2222     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2223     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2224
2225     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2226
2227     PYPRIVATE;
2228 };
2229
2230 IMPLEMENT_DYNAMIC_CLASS(wxPyPanel, wxPanel);
2231
2232 IMP_PYCALLBACK_VOID_INT4(wxPyPanel, wxPanel, DoMoveWindow);
2233 IMP_PYCALLBACK_VOID_INT5(wxPyPanel, wxPanel, DoSetSize);
2234 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetClientSize);
2235 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetVirtualSize);
2236
2237 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetSize);
2238 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetClientSize);
2239 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetPosition);
2240
2241 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetVirtualSize);
2242 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetBestSize);
2243
2244 IMP_PYCALLBACK__(wxPyPanel, wxPanel, InitDialog);
2245 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataFromWindow);
2246 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataToWindow);
2247 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, Validate);
2248
2249 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocus);
2250 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocusFromKeyboard);
2251 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, GetMaxSize);
2252
2253 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, AddChild);
2254 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, RemoveChild);
2255
2256 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, ShouldInheritColours);
2257 IMP_PYCALLBACK__COLOUR(wxPyPanel, wxPanel, ApplyParentThemeBackground);
2258 IMP_PYCALLBACK_VIZATTR_(wxPyPanel, wxPanel, GetDefaultAttributes);
2259
2260 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, HasTransparentBackground);
2261
2262  // C++ version of Python aware wxScrolledWindow
2263 class wxPyScrolledWindow : public wxScrolledWindow
2264 {
2265     DECLARE_DYNAMIC_CLASS(wxPyScrolledWindow)
2266 public:
2267     wxPyScrolledWindow() : wxScrolledWindow() {}
2268     wxPyScrolledWindow(wxWindow* parent, const wxWindowID id,
2269                const wxPoint& pos = wxDefaultPosition,
2270                const wxSize& size = wxDefaultSize,
2271                long style = 0,
2272                const wxString& name = wxPyPanelNameStr)
2273         : wxScrolledWindow(parent, id, pos, size, style, name) {}
2274
2275     void SetBestSize(const wxSize& size) { wxScrolledWindow::SetBestSize(size); }
2276
2277     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2278     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2279     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2280     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2281
2282     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2283     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2284     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2285
2286     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2287     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2288
2289     DEC_PYCALLBACK__(InitDialog);
2290     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2291     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2292     DEC_PYCALLBACK_BOOL_(Validate);
2293
2294     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2295     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2296     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2297
2298     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2299     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2300
2301     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2302     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2303     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2304
2305     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2306
2307     PYPRIVATE;
2308 };
2309
2310 IMPLEMENT_DYNAMIC_CLASS(wxPyScrolledWindow, wxScrolledWindow);
2311
2312 IMP_PYCALLBACK_VOID_INT4(wxPyScrolledWindow, wxScrolledWindow, DoMoveWindow);
2313 IMP_PYCALLBACK_VOID_INT5(wxPyScrolledWindow, wxScrolledWindow, DoSetSize);
2314 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetClientSize);
2315 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetVirtualSize);
2316
2317 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetSize);
2318 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetClientSize);
2319 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetPosition);
2320
2321 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetVirtualSize);
2322 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetBestSize);
2323
2324 IMP_PYCALLBACK__(wxPyScrolledWindow, wxScrolledWindow, InitDialog);
2325 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataFromWindow);
2326 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataToWindow);
2327 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, Validate);
2328
2329 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocus);
2330 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocusFromKeyboard);
2331 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, GetMaxSize);
2332
2333 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, AddChild);
2334 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, RemoveChild);
2335
2336 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, ShouldInheritColours);
2337 IMP_PYCALLBACK__COLOUR(wxPyScrolledWindow, wxScrolledWindow, ApplyParentThemeBackground);
2338 IMP_PYCALLBACK_VIZATTR_(wxPyScrolledWindow, wxScrolledWindow, GetDefaultAttributes);
2339
2340 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, HasTransparentBackground);
2341
2342
2343 #include "wx/wxPython/printfw.h"
2344
2345
2346  static const wxString wxPyPrintoutTitleStr(wxT("Printout"));
2347  static const wxString wxPyPreviewCanvasNameStr(wxT("previewcanvas"));
2348 static PyObject *wxPrintData_GetPrivData(wxPrintData *self){
2349             PyObject* data;
2350             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2351             data = PyString_FromStringAndSize(self->GetPrivData(),
2352                                               self->GetPrivDataLen());
2353             wxPyEndBlockThreads(blocked);
2354             return data;
2355         }
2356 static void wxPrintData_SetPrivData(wxPrintData *self,PyObject *data){
2357             if (! PyString_Check(data)) {
2358                 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2359                                                   "Expected string object"));
2360                 return /* NULL */ ;
2361             }
2362
2363             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2364             self->SetPrivData(PyString_AS_STRING(data), PyString_GET_SIZE(data));
2365             wxPyEndBlockThreads(blocked);
2366         }
2367
2368
2369 IMPLEMENT_ABSTRACT_CLASS(wxPyPrintout, wxPrintout);
2370
2371 // Since this one would be tough and ugly to do with the Macros...
2372 void wxPyPrintout::GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2373     bool hadErr = false;
2374     bool found;
2375
2376     wxPyBlock_t blocked = wxPyBeginBlockThreads();
2377     if ((found = wxPyCBH_findCallback(m_myInst, "GetPageInfo"))) {
2378         PyObject* result = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2379         if (result && PyTuple_Check(result) && PyTuple_Size(result) == 4) {
2380             PyObject* val;
2381
2382             val = PyTuple_GetItem(result, 0);
2383             if (PyInt_Check(val))    *minPage = PyInt_AsLong(val);
2384             else hadErr = true;
2385
2386             val = PyTuple_GetItem(result, 1);
2387             if (PyInt_Check(val))    *maxPage = PyInt_AsLong(val);
2388             else hadErr = true;
2389
2390             val = PyTuple_GetItem(result, 2);
2391             if (PyInt_Check(val))    *pageFrom = PyInt_AsLong(val);
2392             else hadErr = true;
2393
2394             val = PyTuple_GetItem(result, 3);
2395             if (PyInt_Check(val))    *pageTo = PyInt_AsLong(val);
2396             else hadErr = true;
2397         }
2398         else
2399             hadErr = true;
2400
2401         if (hadErr) {
2402             PyErr_SetString(PyExc_TypeError, "GetPageInfo should return a tuple of 4 integers.");
2403             PyErr_Print();
2404         }
2405         Py_DECREF(result);
2406     }
2407     wxPyEndBlockThreads(blocked);
2408     if (! found)
2409         wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2410 }
2411
2412 void wxPyPrintout::base_GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2413     wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2414 }
2415
2416
2417 IMP_PYCALLBACK_BOOL_INTINT(wxPyPrintout, wxPrintout, OnBeginDocument);
2418 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndDocument);
2419 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnBeginPrinting);
2420 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndPrinting);
2421 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnPreparePrinting);
2422 IMP_PYCALLBACK_BOOL_INT_pure(wxPyPrintout, wxPrintout, OnPrintPage);
2423 IMP_PYCALLBACK_BOOL_INT(wxPyPrintout, wxPrintout, HasPage);
2424
2425
2426
2427
2428
2429 #define DEC_PYCALLBACK_BOOL_PREWINDC(CBNAME)                                            \
2430     bool CBNAME(wxPreviewCanvas* a, wxDC& b);                                           \
2431     bool base_##CBNAME(wxPreviewCanvas* a, wxDC& b)
2432
2433
2434 #define IMP_PYCALLBACK_BOOL_PREWINDC(CLASS, PCLASS, CBNAME)                             \
2435     bool CLASS::CBNAME(wxPreviewCanvas* a, wxDC& b) {                                   \
2436         bool rval=false;                                                                \
2437         bool found;                                                                     \
2438         wxPyBlock_t blocked = wxPyBeginBlockThreads();                                         \
2439         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
2440             PyObject* win = wxPyMake_wxObject(a,false);                                 \
2441             PyObject* dc  = wxPyMake_wxObject(&b,false);                                \
2442             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));      \
2443             Py_DECREF(win);                                                             \
2444             Py_DECREF(dc);                                                              \
2445         }                                                                               \
2446         wxPyEndBlockThreads(blocked);                                                   \
2447         if (! found)                                                                    \
2448             rval = PCLASS::CBNAME(a, b);                                                \
2449         return rval;                                                                    \
2450     }                                                                                   \
2451     bool CLASS::base_##CBNAME(wxPreviewCanvas* a, wxDC& b) {                            \
2452         return PCLASS::CBNAME(a, b);                                                    \
2453     }
2454
2455
2456
2457
2458 class wxPyPrintPreview : public wxPrintPreview
2459 {
2460     DECLARE_CLASS(wxPyPrintPreview)
2461 public:
2462     wxPyPrintPreview(wxPyPrintout* printout,
2463                      wxPyPrintout* printoutForPrinting,
2464                      wxPrintDialogData* data=NULL)
2465         : wxPrintPreview(printout, printoutForPrinting, data)
2466     {}
2467     wxPyPrintPreview(wxPyPrintout* printout,
2468                      wxPyPrintout* printoutForPrinting,
2469                      wxPrintData* data=NULL)
2470         : wxPrintPreview(printout, printoutForPrinting, data)
2471     {}
2472
2473     DEC_PYCALLBACK_BOOL_INT(SetCurrentPage);
2474     DEC_PYCALLBACK_BOOL_PREWINDC(PaintPage);
2475     DEC_PYCALLBACK_BOOL_PREWINDC(DrawBlankPage);
2476     DEC_PYCALLBACK_BOOL_INT(RenderPage);
2477     DEC_PYCALLBACK_VOID_INT(SetZoom);
2478     DEC_PYCALLBACK_BOOL_BOOL(Print);
2479     DEC_PYCALLBACK_VOID_(DetermineScaling);
2480
2481     PYPRIVATE;
2482 };
2483
2484 // Stupid renamed classes...  Fix this in 2.5...
2485 #if defined(__WXMSW__)
2486 IMPLEMENT_CLASS( wxPyPrintPreview, wxWindowsPrintPreview );
2487 #elif defined(__WXMAC__)
2488 IMPLEMENT_CLASS( wxPyPrintPreview, wxMacPrintPreview );
2489 #else
2490 IMPLEMENT_CLASS( wxPyPrintPreview, wxPostScriptPrintPreview );
2491 #endif
2492
2493 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, SetCurrentPage);
2494 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, PaintPage);
2495 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, DrawBlankPage);
2496 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, RenderPage);
2497 IMP_PYCALLBACK_VOID_INT     (wxPyPrintPreview, wxPrintPreview, SetZoom);
2498 IMP_PYCALLBACK_BOOL_BOOL    (wxPyPrintPreview, wxPrintPreview, Print);
2499 IMP_PYCALLBACK_VOID_        (wxPyPrintPreview, wxPrintPreview, DetermineScaling);
2500
2501
2502 class wxPyPreviewFrame : public wxPreviewFrame
2503 {
2504     DECLARE_CLASS(wxPyPreviewFrame);
2505 public:
2506     wxPyPreviewFrame(wxPrintPreview* preview, wxFrame* parent,
2507                      const wxString& title,
2508                      const wxPoint& pos = wxDefaultPosition,
2509                      const wxSize&  size = wxDefaultSize,
2510                      long style = wxDEFAULT_FRAME_STYLE,
2511                      const wxString& name = wxPyFrameNameStr)
2512         : wxPreviewFrame(preview, parent, title, pos, size, style, name)
2513     {}
2514
2515     void SetPreviewCanvas(wxPreviewCanvas* canvas) { m_previewCanvas = canvas; }
2516     void SetControlBar(wxPreviewControlBar* bar) { m_controlBar = bar; }
2517
2518     DEC_PYCALLBACK_VOID_(Initialize);
2519     DEC_PYCALLBACK_VOID_(CreateCanvas);
2520     DEC_PYCALLBACK_VOID_(CreateControlBar);
2521
2522     PYPRIVATE;
2523 };
2524
2525 IMPLEMENT_CLASS(wxPyPreviewFrame, wxPreviewFrame);
2526
2527 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, Initialize);
2528 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateCanvas);
2529 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateControlBar);
2530
2531
2532 class wxPyPreviewControlBar : public wxPreviewControlBar
2533 {
2534     DECLARE_CLASS(wxPyPreviewControlBar);
2535 public:
2536     wxPyPreviewControlBar(wxPrintPreview *preview,
2537                           long buttons,
2538                           wxWindow *parent,
2539                           const wxPoint& pos = wxDefaultPosition,
2540                           const wxSize& size = wxDefaultSize,
2541                           long style = 0,
2542                           const wxString& name = wxPyPanelNameStr)
2543         : wxPreviewControlBar(preview, buttons, parent, pos, size, style, name)
2544     {}
2545
2546     void SetPrintPreview(wxPrintPreview* preview) { m_printPreview = preview; }
2547
2548     DEC_PYCALLBACK_VOID_(CreateButtons);
2549     DEC_PYCALLBACK_VOID_INT(SetZoomControl);
2550
2551     PYPRIVATE;
2552 };
2553
2554 IMPLEMENT_CLASS(wxPyPreviewControlBar, wxPreviewControlBar);
2555 IMP_PYCALLBACK_VOID_(wxPyPreviewControlBar, wxPreviewControlBar, CreateButtons);
2556 IMP_PYCALLBACK_VOID_INT(wxPyPreviewControlBar, wxPreviewControlBar, SetZoomControl);
2557
2558 #ifdef __cplusplus
2559 extern "C" {
2560 #endif
2561 static PyObject *_wrap_new_Panel(PyObject *, PyObject *args, PyObject *kwargs) {
2562     PyObject *resultobj;
2563     wxWindow *arg1 = (wxWindow *) 0 ;
2564     int arg2 = (int) (int)-1 ;
2565     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2566     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2567     wxSize const &arg4_defvalue = wxDefaultSize ;
2568     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2569     long arg5 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2570     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2571     wxString *arg6 = (wxString *) &arg6_defvalue ;
2572     wxPanel *result;
2573     wxPoint temp3 ;
2574     wxSize temp4 ;
2575     bool temp6 = false ;
2576     PyObject * obj0 = 0 ;
2577     PyObject * obj1 = 0 ;
2578     PyObject * obj2 = 0 ;
2579     PyObject * obj3 = 0 ;
2580     PyObject * obj4 = 0 ;
2581     PyObject * obj5 = 0 ;
2582     char *kwnames[] = {
2583         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2584     };
2585
2586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Panel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2588     if (SWIG_arg_fail(1)) SWIG_fail;
2589     if (obj1) {
2590         {
2591             arg2 = (int const)(SWIG_As_int(obj1));
2592             if (SWIG_arg_fail(2)) SWIG_fail;
2593         }
2594     }
2595     if (obj2) {
2596         {
2597             arg3 = &temp3;
2598             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2599         }
2600     }
2601     if (obj3) {
2602         {
2603             arg4 = &temp4;
2604             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2605         }
2606     }
2607     if (obj4) {
2608         {
2609             arg5 = (long)(SWIG_As_long(obj4));
2610             if (SWIG_arg_fail(5)) SWIG_fail;
2611         }
2612     }
2613     if (obj5) {
2614         {
2615             arg6 = wxString_in_helper(obj5);
2616             if (arg6 == NULL) SWIG_fail;
2617             temp6 = true;
2618         }
2619     }
2620     {
2621         if (!wxPyCheckForApp()) SWIG_fail;
2622         PyThreadState* __tstate = wxPyBeginAllowThreads();
2623         result = (wxPanel *)new wxPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2624
2625         wxPyEndAllowThreads(__tstate);
2626         if (PyErr_Occurred()) SWIG_fail;
2627     }
2628     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2629     {
2630         if (temp6)
2631         delete arg6;
2632     }
2633     return resultobj;
2634     fail:
2635     {
2636         if (temp6)
2637         delete arg6;
2638     }
2639     return NULL;
2640 }
2641
2642
2643 static PyObject *_wrap_new_PrePanel(PyObject *, PyObject *args, PyObject *kwargs) {
2644     PyObject *resultobj;
2645     wxPanel *result;
2646     char *kwnames[] = {
2647         NULL
2648     };
2649
2650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePanel",kwnames)) goto fail;
2651     {
2652         if (!wxPyCheckForApp()) SWIG_fail;
2653         PyThreadState* __tstate = wxPyBeginAllowThreads();
2654         result = (wxPanel *)new wxPanel();
2655
2656         wxPyEndAllowThreads(__tstate);
2657         if (PyErr_Occurred()) SWIG_fail;
2658     }
2659     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2660     return resultobj;
2661     fail:
2662     return NULL;
2663 }
2664
2665
2666 static PyObject *_wrap_Panel_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2667     PyObject *resultobj;
2668     wxPanel *arg1 = (wxPanel *) 0 ;
2669     wxWindow *arg2 = (wxWindow *) 0 ;
2670     int arg3 = (int) (int)-1 ;
2671     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2672     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2673     wxSize const &arg5_defvalue = wxDefaultSize ;
2674     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2675     long arg6 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2676     wxString const &arg7_defvalue = wxPyPanelNameStr ;
2677     wxString *arg7 = (wxString *) &arg7_defvalue ;
2678     bool result;
2679     wxPoint temp4 ;
2680     wxSize temp5 ;
2681     bool temp7 = false ;
2682     PyObject * obj0 = 0 ;
2683     PyObject * obj1 = 0 ;
2684     PyObject * obj2 = 0 ;
2685     PyObject * obj3 = 0 ;
2686     PyObject * obj4 = 0 ;
2687     PyObject * obj5 = 0 ;
2688     PyObject * obj6 = 0 ;
2689     char *kwnames[] = {
2690         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2691     };
2692
2693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Panel_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2694     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2695     if (SWIG_arg_fail(1)) SWIG_fail;
2696     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2697     if (SWIG_arg_fail(2)) SWIG_fail;
2698     if (obj2) {
2699         {
2700             arg3 = (int const)(SWIG_As_int(obj2));
2701             if (SWIG_arg_fail(3)) SWIG_fail;
2702         }
2703     }
2704     if (obj3) {
2705         {
2706             arg4 = &temp4;
2707             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2708         }
2709     }
2710     if (obj4) {
2711         {
2712             arg5 = &temp5;
2713             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2714         }
2715     }
2716     if (obj5) {
2717         {
2718             arg6 = (long)(SWIG_As_long(obj5));
2719             if (SWIG_arg_fail(6)) SWIG_fail;
2720         }
2721     }
2722     if (obj6) {
2723         {
2724             arg7 = wxString_in_helper(obj6);
2725             if (arg7 == NULL) SWIG_fail;
2726             temp7 = true;
2727         }
2728     }
2729     {
2730         PyThreadState* __tstate = wxPyBeginAllowThreads();
2731         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
2732
2733         wxPyEndAllowThreads(__tstate);
2734         if (PyErr_Occurred()) SWIG_fail;
2735     }
2736     {
2737         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2738     }
2739     {
2740         if (temp7)
2741         delete arg7;
2742     }
2743     return resultobj;
2744     fail:
2745     {
2746         if (temp7)
2747         delete arg7;
2748     }
2749     return NULL;
2750 }
2751
2752
2753 static PyObject *_wrap_Panel_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
2754     PyObject *resultobj;
2755     wxPanel *arg1 = (wxPanel *) 0 ;
2756     PyObject * obj0 = 0 ;
2757     char *kwnames[] = {
2758         (char *) "self", NULL
2759     };
2760
2761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_InitDialog",kwnames,&obj0)) goto fail;
2762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2763     if (SWIG_arg_fail(1)) SWIG_fail;
2764     {
2765         PyThreadState* __tstate = wxPyBeginAllowThreads();
2766         (arg1)->InitDialog();
2767
2768         wxPyEndAllowThreads(__tstate);
2769         if (PyErr_Occurred()) SWIG_fail;
2770     }
2771     Py_INCREF(Py_None); resultobj = Py_None;
2772     return resultobj;
2773     fail:
2774     return NULL;
2775 }
2776
2777
2778 static PyObject *_wrap_Panel_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
2779     PyObject *resultobj;
2780     wxPanel *arg1 = (wxPanel *) 0 ;
2781     PyObject * obj0 = 0 ;
2782     char *kwnames[] = {
2783         (char *) "self", NULL
2784     };
2785
2786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocus",kwnames,&obj0)) goto fail;
2787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2788     if (SWIG_arg_fail(1)) SWIG_fail;
2789     {
2790         PyThreadState* __tstate = wxPyBeginAllowThreads();
2791         (arg1)->SetFocus();
2792
2793         wxPyEndAllowThreads(__tstate);
2794         if (PyErr_Occurred()) SWIG_fail;
2795     }
2796     Py_INCREF(Py_None); resultobj = Py_None;
2797     return resultobj;
2798     fail:
2799     return NULL;
2800 }
2801
2802
2803 static PyObject *_wrap_Panel_SetFocusIgnoringChildren(PyObject *, PyObject *args, PyObject *kwargs) {
2804     PyObject *resultobj;
2805     wxPanel *arg1 = (wxPanel *) 0 ;
2806     PyObject * obj0 = 0 ;
2807     char *kwnames[] = {
2808         (char *) "self", NULL
2809     };
2810
2811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocusIgnoringChildren",kwnames,&obj0)) goto fail;
2812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2813     if (SWIG_arg_fail(1)) SWIG_fail;
2814     {
2815         PyThreadState* __tstate = wxPyBeginAllowThreads();
2816         (arg1)->SetFocusIgnoringChildren();
2817
2818         wxPyEndAllowThreads(__tstate);
2819         if (PyErr_Occurred()) SWIG_fail;
2820     }
2821     Py_INCREF(Py_None); resultobj = Py_None;
2822     return resultobj;
2823     fail:
2824     return NULL;
2825 }
2826
2827
2828 static PyObject *_wrap_Panel_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
2829     PyObject *resultobj;
2830     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
2831     wxVisualAttributes result;
2832     PyObject * obj0 = 0 ;
2833     char *kwnames[] = {
2834         (char *) "variant", NULL
2835     };
2836
2837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Panel_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
2838     if (obj0) {
2839         {
2840             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
2841             if (SWIG_arg_fail(1)) SWIG_fail;
2842         }
2843     }
2844     {
2845         if (!wxPyCheckForApp()) SWIG_fail;
2846         PyThreadState* __tstate = wxPyBeginAllowThreads();
2847         result = wxPanel::GetClassDefaultAttributes((wxWindowVariant )arg1);
2848
2849         wxPyEndAllowThreads(__tstate);
2850         if (PyErr_Occurred()) SWIG_fail;
2851     }
2852     {
2853         wxVisualAttributes * resultptr;
2854         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
2855         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
2856     }
2857     return resultobj;
2858     fail:
2859     return NULL;
2860 }
2861
2862
2863 static PyObject * Panel_swigregister(PyObject *, PyObject *args) {
2864     PyObject *obj;
2865     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2866     SWIG_TypeClientData(SWIGTYPE_p_wxPanel, obj);
2867     Py_INCREF(obj);
2868     return Py_BuildValue((char *)"");
2869 }
2870 static PyObject *_wrap_new_ScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2871     PyObject *resultobj;
2872     wxWindow *arg1 = (wxWindow *) 0 ;
2873     int arg2 = (int) (int)-1 ;
2874     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2875     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2876     wxSize const &arg4_defvalue = wxDefaultSize ;
2877     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2878     long arg5 = (long) wxHSCROLL|wxVSCROLL ;
2879     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2880     wxString *arg6 = (wxString *) &arg6_defvalue ;
2881     wxScrolledWindow *result;
2882     wxPoint temp3 ;
2883     wxSize temp4 ;
2884     bool temp6 = false ;
2885     PyObject * obj0 = 0 ;
2886     PyObject * obj1 = 0 ;
2887     PyObject * obj2 = 0 ;
2888     PyObject * obj3 = 0 ;
2889     PyObject * obj4 = 0 ;
2890     PyObject * obj5 = 0 ;
2891     char *kwnames[] = {
2892         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2893     };
2894
2895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2897     if (SWIG_arg_fail(1)) SWIG_fail;
2898     if (obj1) {
2899         {
2900             arg2 = (int const)(SWIG_As_int(obj1));
2901             if (SWIG_arg_fail(2)) SWIG_fail;
2902         }
2903     }
2904     if (obj2) {
2905         {
2906             arg3 = &temp3;
2907             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2908         }
2909     }
2910     if (obj3) {
2911         {
2912             arg4 = &temp4;
2913             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2914         }
2915     }
2916     if (obj4) {
2917         {
2918             arg5 = (long)(SWIG_As_long(obj4));
2919             if (SWIG_arg_fail(5)) SWIG_fail;
2920         }
2921     }
2922     if (obj5) {
2923         {
2924             arg6 = wxString_in_helper(obj5);
2925             if (arg6 == NULL) SWIG_fail;
2926             temp6 = true;
2927         }
2928     }
2929     {
2930         if (!wxPyCheckForApp()) SWIG_fail;
2931         PyThreadState* __tstate = wxPyBeginAllowThreads();
2932         result = (wxScrolledWindow *)new wxScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2933
2934         wxPyEndAllowThreads(__tstate);
2935         if (PyErr_Occurred()) SWIG_fail;
2936     }
2937     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2938     {
2939         if (temp6)
2940         delete arg6;
2941     }
2942     return resultobj;
2943     fail:
2944     {
2945         if (temp6)
2946         delete arg6;
2947     }
2948     return NULL;
2949 }
2950
2951
2952 static PyObject *_wrap_new_PreScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2953     PyObject *resultobj;
2954     wxScrolledWindow *result;
2955     char *kwnames[] = {
2956         NULL
2957     };
2958
2959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreScrolledWindow",kwnames)) goto fail;
2960     {
2961         if (!wxPyCheckForApp()) SWIG_fail;
2962         PyThreadState* __tstate = wxPyBeginAllowThreads();
2963         result = (wxScrolledWindow *)new wxScrolledWindow();
2964
2965         wxPyEndAllowThreads(__tstate);
2966         if (PyErr_Occurred()) SWIG_fail;
2967     }
2968     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2969     return resultobj;
2970     fail:
2971     return NULL;
2972 }
2973
2974
2975 static PyObject *_wrap_ScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2976     PyObject *resultobj;
2977     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
2978     wxWindow *arg2 = (wxWindow *) 0 ;
2979     int arg3 = (int) (int)-1 ;
2980     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2981     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2982     wxSize const &arg5_defvalue = wxDefaultSize ;
2983     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2984     long arg6 = (long) wxHSCROLL|wxVSCROLL ;
2985     wxString const &arg7_defvalue = wxPyPanelNameStr ;
2986     wxString *arg7 = (wxString *) &arg7_defvalue ;
2987     bool result;
2988     wxPoint temp4 ;
2989     wxSize temp5 ;
2990     bool temp7 = false ;
2991     PyObject * obj0 = 0 ;
2992     PyObject * obj1 = 0 ;
2993     PyObject * obj2 = 0 ;
2994     PyObject * obj3 = 0 ;
2995     PyObject * obj4 = 0 ;
2996     PyObject * obj5 = 0 ;
2997     PyObject * obj6 = 0 ;
2998     char *kwnames[] = {
2999         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
3000     };
3001
3002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3003     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3004     if (SWIG_arg_fail(1)) SWIG_fail;
3005     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3006     if (SWIG_arg_fail(2)) SWIG_fail;
3007     if (obj2) {
3008         {
3009             arg3 = (int const)(SWIG_As_int(obj2));
3010             if (SWIG_arg_fail(3)) SWIG_fail;
3011         }
3012     }
3013     if (obj3) {
3014         {
3015             arg4 = &temp4;
3016             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3017         }
3018     }
3019     if (obj4) {
3020         {
3021             arg5 = &temp5;
3022             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3023         }
3024     }
3025     if (obj5) {
3026         {
3027             arg6 = (long)(SWIG_As_long(obj5));
3028             if (SWIG_arg_fail(6)) SWIG_fail;
3029         }
3030     }
3031     if (obj6) {
3032         {
3033             arg7 = wxString_in_helper(obj6);
3034             if (arg7 == NULL) SWIG_fail;
3035             temp7 = true;
3036         }
3037     }
3038     {
3039         PyThreadState* __tstate = wxPyBeginAllowThreads();
3040         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
3041
3042         wxPyEndAllowThreads(__tstate);
3043         if (PyErr_Occurred()) SWIG_fail;
3044     }
3045     {
3046         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3047     }
3048     {
3049         if (temp7)
3050         delete arg7;
3051     }
3052     return resultobj;
3053     fail:
3054     {
3055         if (temp7)
3056         delete arg7;
3057     }
3058     return NULL;
3059 }
3060
3061
3062 static PyObject *_wrap_ScrolledWindow_SetScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3063     PyObject *resultobj;
3064     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3065     int arg2 ;
3066     int arg3 ;
3067     int arg4 ;
3068     int arg5 ;
3069     int arg6 = (int) 0 ;
3070     int arg7 = (int) 0 ;
3071     bool arg8 = (bool) false ;
3072     PyObject * obj0 = 0 ;
3073     PyObject * obj1 = 0 ;
3074     PyObject * obj2 = 0 ;
3075     PyObject * obj3 = 0 ;
3076     PyObject * obj4 = 0 ;
3077     PyObject * obj5 = 0 ;
3078     PyObject * obj6 = 0 ;
3079     PyObject * obj7 = 0 ;
3080     char *kwnames[] = {
3081         (char *) "self",(char *) "pixelsPerUnitX",(char *) "pixelsPerUnitY",(char *) "noUnitsX",(char *) "noUnitsY",(char *) "xPos",(char *) "yPos",(char *) "noRefresh", NULL
3082     };
3083
3084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:ScrolledWindow_SetScrollbars",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3085     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3086     if (SWIG_arg_fail(1)) SWIG_fail;
3087     {
3088         arg2 = (int)(SWIG_As_int(obj1));
3089         if (SWIG_arg_fail(2)) SWIG_fail;
3090     }
3091     {
3092         arg3 = (int)(SWIG_As_int(obj2));
3093         if (SWIG_arg_fail(3)) SWIG_fail;
3094     }
3095     {
3096         arg4 = (int)(SWIG_As_int(obj3));
3097         if (SWIG_arg_fail(4)) SWIG_fail;
3098     }
3099     {
3100         arg5 = (int)(SWIG_As_int(obj4));
3101         if (SWIG_arg_fail(5)) SWIG_fail;
3102     }
3103     if (obj5) {
3104         {
3105             arg6 = (int)(SWIG_As_int(obj5));
3106             if (SWIG_arg_fail(6)) SWIG_fail;
3107         }
3108     }
3109     if (obj6) {
3110         {
3111             arg7 = (int)(SWIG_As_int(obj6));
3112             if (SWIG_arg_fail(7)) SWIG_fail;
3113         }
3114     }
3115     if (obj7) {
3116         {
3117             arg8 = (bool)(SWIG_As_bool(obj7));
3118             if (SWIG_arg_fail(8)) SWIG_fail;
3119         }
3120     }
3121     {
3122         PyThreadState* __tstate = wxPyBeginAllowThreads();
3123         (arg1)->SetScrollbars(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3124
3125         wxPyEndAllowThreads(__tstate);
3126         if (PyErr_Occurred()) SWIG_fail;
3127     }
3128     Py_INCREF(Py_None); resultobj = Py_None;
3129     return resultobj;
3130     fail:
3131     return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_ScrolledWindow_Scroll(PyObject *, PyObject *args, PyObject *kwargs) {
3136     PyObject *resultobj;
3137     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3138     int arg2 ;
3139     int arg3 ;
3140     PyObject * obj0 = 0 ;
3141     PyObject * obj1 = 0 ;
3142     PyObject * obj2 = 0 ;
3143     char *kwnames[] = {
3144         (char *) "self",(char *) "x",(char *) "y", NULL
3145     };
3146
3147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_Scroll",kwnames,&obj0,&obj1,&obj2)) goto fail;
3148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3149     if (SWIG_arg_fail(1)) SWIG_fail;
3150     {
3151         arg2 = (int)(SWIG_As_int(obj1));
3152         if (SWIG_arg_fail(2)) SWIG_fail;
3153     }
3154     {
3155         arg3 = (int)(SWIG_As_int(obj2));
3156         if (SWIG_arg_fail(3)) SWIG_fail;
3157     }
3158     {
3159         PyThreadState* __tstate = wxPyBeginAllowThreads();
3160         (arg1)->Scroll(arg2,arg3);
3161
3162         wxPyEndAllowThreads(__tstate);
3163         if (PyErr_Occurred()) SWIG_fail;
3164     }
3165     Py_INCREF(Py_None); resultobj = Py_None;
3166     return resultobj;
3167     fail:
3168     return NULL;
3169 }
3170
3171
3172 static PyObject *_wrap_ScrolledWindow_GetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3173     PyObject *resultobj;
3174     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3175     int arg2 ;
3176     int result;
3177     PyObject * obj0 = 0 ;
3178     PyObject * obj1 = 0 ;
3179     char *kwnames[] = {
3180         (char *) "self",(char *) "orient", NULL
3181     };
3182
3183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_GetScrollPageSize",kwnames,&obj0,&obj1)) goto fail;
3184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3185     if (SWIG_arg_fail(1)) SWIG_fail;
3186     {
3187         arg2 = (int)(SWIG_As_int(obj1));
3188         if (SWIG_arg_fail(2)) SWIG_fail;
3189     }
3190     {
3191         PyThreadState* __tstate = wxPyBeginAllowThreads();
3192         result = (int)((wxScrolledWindow const *)arg1)->GetScrollPageSize(arg2);
3193
3194         wxPyEndAllowThreads(__tstate);
3195         if (PyErr_Occurred()) SWIG_fail;
3196     }
3197     {
3198         resultobj = SWIG_From_int((int)(result));
3199     }
3200     return resultobj;
3201     fail:
3202     return NULL;
3203 }
3204
3205
3206 static PyObject *_wrap_ScrolledWindow_SetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3207     PyObject *resultobj;
3208     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3209     int arg2 ;
3210     int arg3 ;
3211     PyObject * obj0 = 0 ;
3212     PyObject * obj1 = 0 ;
3213     PyObject * obj2 = 0 ;
3214     char *kwnames[] = {
3215         (char *) "self",(char *) "orient",(char *) "pageSize", NULL
3216     };
3217
3218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollPageSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
3219     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3220     if (SWIG_arg_fail(1)) SWIG_fail;
3221     {
3222         arg2 = (int)(SWIG_As_int(obj1));
3223         if (SWIG_arg_fail(2)) SWIG_fail;
3224     }
3225     {
3226         arg3 = (int)(SWIG_As_int(obj2));
3227         if (SWIG_arg_fail(3)) SWIG_fail;
3228     }
3229     {
3230         PyThreadState* __tstate = wxPyBeginAllowThreads();
3231         (arg1)->SetScrollPageSize(arg2,arg3);
3232
3233         wxPyEndAllowThreads(__tstate);
3234         if (PyErr_Occurred()) SWIG_fail;
3235     }
3236     Py_INCREF(Py_None); resultobj = Py_None;
3237     return resultobj;
3238     fail:
3239     return NULL;
3240 }
3241
3242
3243 static PyObject *_wrap_ScrolledWindow_SetScrollRate(PyObject *, PyObject *args, PyObject *kwargs) {
3244     PyObject *resultobj;
3245     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3246     int arg2 ;
3247     int arg3 ;
3248     PyObject * obj0 = 0 ;
3249     PyObject * obj1 = 0 ;
3250     PyObject * obj2 = 0 ;
3251     char *kwnames[] = {
3252         (char *) "self",(char *) "xstep",(char *) "ystep", NULL
3253     };
3254
3255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollRate",kwnames,&obj0,&obj1,&obj2)) goto fail;
3256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3257     if (SWIG_arg_fail(1)) SWIG_fail;
3258     {
3259         arg2 = (int)(SWIG_As_int(obj1));
3260         if (SWIG_arg_fail(2)) SWIG_fail;
3261     }
3262     {
3263         arg3 = (int)(SWIG_As_int(obj2));
3264         if (SWIG_arg_fail(3)) SWIG_fail;
3265     }
3266     {
3267         PyThreadState* __tstate = wxPyBeginAllowThreads();
3268         (arg1)->SetScrollRate(arg2,arg3);
3269
3270         wxPyEndAllowThreads(__tstate);
3271         if (PyErr_Occurred()) SWIG_fail;
3272     }
3273     Py_INCREF(Py_None); resultobj = Py_None;
3274     return resultobj;
3275     fail:
3276     return NULL;
3277 }
3278
3279
3280 static PyObject *_wrap_ScrolledWindow_GetScrollPixelsPerUnit(PyObject *, PyObject *args, PyObject *kwargs) {
3281     PyObject *resultobj;
3282     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3283     int *arg2 = (int *) 0 ;
3284     int *arg3 = (int *) 0 ;
3285     int temp2 ;
3286     int res2 = 0 ;
3287     int temp3 ;
3288     int res3 = 0 ;
3289     PyObject * obj0 = 0 ;
3290     char *kwnames[] = {
3291         (char *) "self", NULL
3292     };
3293
3294     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3295     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScrollPixelsPerUnit",kwnames,&obj0)) goto fail;
3297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3298     if (SWIG_arg_fail(1)) SWIG_fail;
3299     {
3300         PyThreadState* __tstate = wxPyBeginAllowThreads();
3301         ((wxScrolledWindow const *)arg1)->GetScrollPixelsPerUnit(arg2,arg3);
3302
3303         wxPyEndAllowThreads(__tstate);
3304         if (PyErr_Occurred()) SWIG_fail;
3305     }
3306     Py_INCREF(Py_None); resultobj = Py_None;
3307     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3308     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3309     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3310     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3311     return resultobj;
3312     fail:
3313     return NULL;
3314 }
3315
3316
3317 static PyObject *_wrap_ScrolledWindow_EnableScrolling(PyObject *, PyObject *args, PyObject *kwargs) {
3318     PyObject *resultobj;
3319     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3320     bool arg2 ;
3321     bool arg3 ;
3322     PyObject * obj0 = 0 ;
3323     PyObject * obj1 = 0 ;
3324     PyObject * obj2 = 0 ;
3325     char *kwnames[] = {
3326         (char *) "self",(char *) "x_scrolling",(char *) "y_scrolling", NULL
3327     };
3328
3329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_EnableScrolling",kwnames,&obj0,&obj1,&obj2)) goto fail;
3330     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3331     if (SWIG_arg_fail(1)) SWIG_fail;
3332     {
3333         arg2 = (bool)(SWIG_As_bool(obj1));
3334         if (SWIG_arg_fail(2)) SWIG_fail;
3335     }
3336     {
3337         arg3 = (bool)(SWIG_As_bool(obj2));
3338         if (SWIG_arg_fail(3)) SWIG_fail;
3339     }
3340     {
3341         PyThreadState* __tstate = wxPyBeginAllowThreads();
3342         (arg1)->EnableScrolling(arg2,arg3);
3343
3344         wxPyEndAllowThreads(__tstate);
3345         if (PyErr_Occurred()) SWIG_fail;
3346     }
3347     Py_INCREF(Py_None); resultobj = Py_None;
3348     return resultobj;
3349     fail:
3350     return NULL;
3351 }
3352
3353
3354 static PyObject *_wrap_ScrolledWindow_GetViewStart(PyObject *, PyObject *args, PyObject *kwargs) {
3355     PyObject *resultobj;
3356     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3357     int *arg2 = (int *) 0 ;
3358     int *arg3 = (int *) 0 ;
3359     int temp2 ;
3360     int res2 = 0 ;
3361     int temp3 ;
3362     int res3 = 0 ;
3363     PyObject * obj0 = 0 ;
3364     char *kwnames[] = {
3365         (char *) "self", NULL
3366     };
3367
3368     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3369     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3370     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetViewStart",kwnames,&obj0)) goto fail;
3371     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3372     if (SWIG_arg_fail(1)) SWIG_fail;
3373     {
3374         PyThreadState* __tstate = wxPyBeginAllowThreads();
3375         ((wxScrolledWindow const *)arg1)->GetViewStart(arg2,arg3);
3376
3377         wxPyEndAllowThreads(__tstate);
3378         if (PyErr_Occurred()) SWIG_fail;
3379     }
3380     Py_INCREF(Py_None); resultobj = Py_None;
3381     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3382     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3383     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3384     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3385     return resultobj;
3386     fail:
3387     return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_ScrolledWindow_SetScale(PyObject *, PyObject *args, PyObject *kwargs) {
3392     PyObject *resultobj;
3393     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3394     double arg2 ;
3395     double arg3 ;
3396     PyObject * obj0 = 0 ;
3397     PyObject * obj1 = 0 ;
3398     PyObject * obj2 = 0 ;
3399     char *kwnames[] = {
3400         (char *) "self",(char *) "xs",(char *) "ys", NULL
3401     };
3402
3403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
3404     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3405     if (SWIG_arg_fail(1)) SWIG_fail;
3406     {
3407         arg2 = (double)(SWIG_As_double(obj1));
3408         if (SWIG_arg_fail(2)) SWIG_fail;
3409     }
3410     {
3411         arg3 = (double)(SWIG_As_double(obj2));
3412         if (SWIG_arg_fail(3)) SWIG_fail;
3413     }
3414     {
3415         PyThreadState* __tstate = wxPyBeginAllowThreads();
3416         (arg1)->SetScale(arg2,arg3);
3417
3418         wxPyEndAllowThreads(__tstate);
3419         if (PyErr_Occurred()) SWIG_fail;
3420     }
3421     Py_INCREF(Py_None); resultobj = Py_None;
3422     return resultobj;
3423     fail:
3424     return NULL;
3425 }
3426
3427
3428 static PyObject *_wrap_ScrolledWindow_GetScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
3429     PyObject *resultobj;
3430     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3431     double result;
3432     PyObject * obj0 = 0 ;
3433     char *kwnames[] = {
3434         (char *) "self", NULL
3435     };
3436
3437     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleX",kwnames,&obj0)) goto fail;
3438     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3439     if (SWIG_arg_fail(1)) SWIG_fail;
3440     {
3441         PyThreadState* __tstate = wxPyBeginAllowThreads();
3442         result = (double)((wxScrolledWindow const *)arg1)->GetScaleX();
3443
3444         wxPyEndAllowThreads(__tstate);
3445         if (PyErr_Occurred()) SWIG_fail;
3446     }
3447     {
3448         resultobj = SWIG_From_double((double)(result));
3449     }
3450     return resultobj;
3451     fail:
3452     return NULL;
3453 }
3454
3455
3456 static PyObject *_wrap_ScrolledWindow_GetScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
3457     PyObject *resultobj;
3458     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3459     double result;
3460     PyObject * obj0 = 0 ;
3461     char *kwnames[] = {
3462         (char *) "self", NULL
3463     };
3464
3465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleY",kwnames,&obj0)) goto fail;
3466     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3467     if (SWIG_arg_fail(1)) SWIG_fail;
3468     {
3469         PyThreadState* __tstate = wxPyBeginAllowThreads();
3470         result = (double)((wxScrolledWindow const *)arg1)->GetScaleY();
3471
3472         wxPyEndAllowThreads(__tstate);
3473         if (PyErr_Occurred()) SWIG_fail;
3474     }
3475     {
3476         resultobj = SWIG_From_double((double)(result));
3477     }
3478     return resultobj;
3479     fail:
3480     return NULL;
3481 }
3482
3483
3484 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3485     PyObject *resultobj;
3486     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3487     wxPoint *arg2 = 0 ;
3488     wxPoint result;
3489     wxPoint temp2 ;
3490     PyObject * obj0 = 0 ;
3491     PyObject * obj1 = 0 ;
3492
3493     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
3494     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3495     if (SWIG_arg_fail(1)) SWIG_fail;
3496     {
3497         arg2 = &temp2;
3498         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3499     }
3500     {
3501         PyThreadState* __tstate = wxPyBeginAllowThreads();
3502         result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
3503
3504         wxPyEndAllowThreads(__tstate);
3505         if (PyErr_Occurred()) SWIG_fail;
3506     }
3507     {
3508         wxPoint * resultptr;
3509         resultptr = new wxPoint((wxPoint &)(result));
3510         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3511     }
3512     return resultobj;
3513     fail:
3514     return NULL;
3515 }
3516
3517
3518 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3519     PyObject *resultobj;
3520     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3521     int arg2 ;
3522     int arg3 ;
3523     int *arg4 = (int *) 0 ;
3524     int *arg5 = (int *) 0 ;
3525     int temp4 ;
3526     int res4 = 0 ;
3527     int temp5 ;
3528     int res5 = 0 ;
3529     PyObject * obj0 = 0 ;
3530     PyObject * obj1 = 0 ;
3531     PyObject * obj2 = 0 ;
3532
3533     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3534     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3535     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3536     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3537     if (SWIG_arg_fail(1)) SWIG_fail;
3538     {
3539         arg2 = (int)(SWIG_As_int(obj1));
3540         if (SWIG_arg_fail(2)) SWIG_fail;
3541     }
3542     {
3543         arg3 = (int)(SWIG_As_int(obj2));
3544         if (SWIG_arg_fail(3)) SWIG_fail;
3545     }
3546     {
3547         PyThreadState* __tstate = wxPyBeginAllowThreads();
3548         ((wxScrolledWindow const *)arg1)->CalcScrolledPosition(arg2,arg3,arg4,arg5);
3549
3550         wxPyEndAllowThreads(__tstate);
3551         if (PyErr_Occurred()) SWIG_fail;
3552     }
3553     Py_INCREF(Py_None); resultobj = Py_None;
3554     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3555     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3556     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3557     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3558     return resultobj;
3559     fail:
3560     return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObject *args) {
3565     int argc;
3566     PyObject *argv[4];
3567     int ii;
3568
3569     argc = PyObject_Length(args);
3570     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3571         argv[ii] = PyTuple_GetItem(args,ii);
3572     }
3573     if (argc == 2) {
3574         int _v;
3575         {
3576             void *ptr;
3577             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3578                 _v = 0;
3579                 PyErr_Clear();
3580             } else {
3581                 _v = 1;
3582             }
3583         }
3584         if (_v) {
3585             {
3586                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3587             }
3588             if (_v) {
3589                 return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
3590             }
3591         }
3592     }
3593     if (argc == 3) {
3594         int _v;
3595         {
3596             void *ptr;
3597             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3598                 _v = 0;
3599                 PyErr_Clear();
3600             } else {
3601                 _v = 1;
3602             }
3603         }
3604         if (_v) {
3605             _v = SWIG_Check_int(argv[1]);
3606             if (_v) {
3607                 _v = SWIG_Check_int(argv[2]);
3608                 if (_v) {
3609                     return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
3610                 }
3611             }
3612         }
3613     }
3614
3615     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcScrolledPosition'");
3616     return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3621     PyObject *resultobj;
3622     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3623     wxPoint *arg2 = 0 ;
3624     wxPoint result;
3625     wxPoint temp2 ;
3626     PyObject * obj0 = 0 ;
3627     PyObject * obj1 = 0 ;
3628
3629     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
3630     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3631     if (SWIG_arg_fail(1)) SWIG_fail;
3632     {
3633         arg2 = &temp2;
3634         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3635     }
3636     {
3637         PyThreadState* __tstate = wxPyBeginAllowThreads();
3638         result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
3639
3640         wxPyEndAllowThreads(__tstate);
3641         if (PyErr_Occurred()) SWIG_fail;
3642     }
3643     {
3644         wxPoint * resultptr;
3645         resultptr = new wxPoint((wxPoint &)(result));
3646         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3647     }
3648     return resultobj;
3649     fail:
3650     return NULL;
3651 }
3652
3653
3654 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3655     PyObject *resultobj;
3656     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3657     int arg2 ;
3658     int arg3 ;
3659     int *arg4 = (int *) 0 ;
3660     int *arg5 = (int *) 0 ;
3661     int temp4 ;
3662     int res4 = 0 ;
3663     int temp5 ;
3664     int res5 = 0 ;
3665     PyObject * obj0 = 0 ;
3666     PyObject * obj1 = 0 ;
3667     PyObject * obj2 = 0 ;
3668
3669     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3670     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3671     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3673     if (SWIG_arg_fail(1)) SWIG_fail;
3674     {
3675         arg2 = (int)(SWIG_As_int(obj1));
3676         if (SWIG_arg_fail(2)) SWIG_fail;
3677     }
3678     {
3679         arg3 = (int)(SWIG_As_int(obj2));
3680         if (SWIG_arg_fail(3)) SWIG_fail;
3681     }
3682     {
3683         PyThreadState* __tstate = wxPyBeginAllowThreads();
3684         ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition(arg2,arg3,arg4,arg5);
3685
3686         wxPyEndAllowThreads(__tstate);
3687         if (PyErr_Occurred()) SWIG_fail;
3688     }
3689     Py_INCREF(Py_None); resultobj = Py_None;
3690     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3691     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3692     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3693     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3694     return resultobj;
3695     fail:
3696     return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyObject *args) {
3701     int argc;
3702     PyObject *argv[4];
3703     int ii;
3704
3705     argc = PyObject_Length(args);
3706     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3707         argv[ii] = PyTuple_GetItem(args,ii);
3708     }
3709     if (argc == 2) {
3710         int _v;
3711         {
3712             void *ptr;
3713             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3714                 _v = 0;
3715                 PyErr_Clear();
3716             } else {
3717                 _v = 1;
3718             }
3719         }
3720         if (_v) {
3721             {
3722                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3723             }
3724             if (_v) {
3725                 return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
3726             }
3727         }
3728     }
3729     if (argc == 3) {
3730         int _v;
3731         {
3732             void *ptr;
3733             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3734                 _v = 0;
3735                 PyErr_Clear();
3736             } else {
3737                 _v = 1;
3738             }
3739         }
3740         if (_v) {
3741             _v = SWIG_Check_int(argv[1]);
3742             if (_v) {
3743                 _v = SWIG_Check_int(argv[2]);
3744                 if (_v) {
3745                     return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
3746                 }
3747             }
3748         }
3749     }
3750
3751     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcUnscrolledPosition'");
3752     return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_ScrolledWindow_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3757     PyObject *resultobj;
3758     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3759     PyObject * obj0 = 0 ;
3760     char *kwnames[] = {
3761         (char *) "self", NULL
3762     };
3763
3764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_AdjustScrollbars",kwnames,&obj0)) goto fail;
3765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3766     if (SWIG_arg_fail(1)) SWIG_fail;
3767     {
3768         PyThreadState* __tstate = wxPyBeginAllowThreads();
3769         (arg1)->AdjustScrollbars();
3770
3771         wxPyEndAllowThreads(__tstate);
3772         if (PyErr_Occurred()) SWIG_fail;
3773     }
3774     Py_INCREF(Py_None); resultobj = Py_None;
3775     return resultobj;
3776     fail:
3777     return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_ScrolledWindow_CalcScrollInc(PyObject *, PyObject *args, PyObject *kwargs) {
3782     PyObject *resultobj;
3783     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3784     wxScrollWinEvent *arg2 = 0 ;
3785     int result;
3786     PyObject * obj0 = 0 ;
3787     PyObject * obj1 = 0 ;
3788     char *kwnames[] = {
3789         (char *) "self",(char *) "event", NULL
3790     };
3791
3792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_CalcScrollInc",kwnames,&obj0,&obj1)) goto fail;
3793     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3794     if (SWIG_arg_fail(1)) SWIG_fail;
3795     {
3796         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
3797         if (SWIG_arg_fail(2)) SWIG_fail;
3798         if (arg2 == NULL) {
3799             SWIG_null_ref("wxScrollWinEvent");
3800         }
3801         if (SWIG_arg_fail(2)) SWIG_fail;
3802     }
3803     {
3804         PyThreadState* __tstate = wxPyBeginAllowThreads();
3805         result = (int)(arg1)->CalcScrollInc(*arg2);
3806
3807         wxPyEndAllowThreads(__tstate);
3808         if (PyErr_Occurred()) SWIG_fail;
3809     }
3810     {
3811         resultobj = SWIG_From_int((int)(result));
3812     }
3813     return resultobj;
3814     fail:
3815     return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_ScrolledWindow_SetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3820     PyObject *resultobj;
3821     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3822     wxWindow *arg2 = (wxWindow *) 0 ;
3823     PyObject * obj0 = 0 ;
3824     PyObject * obj1 = 0 ;
3825     char *kwnames[] = {
3826         (char *) "self",(char *) "target", NULL
3827     };
3828
3829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetWindow",kwnames,&obj0,&obj1)) goto fail;
3830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3831     if (SWIG_arg_fail(1)) SWIG_fail;
3832     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3833     if (SWIG_arg_fail(2)) SWIG_fail;
3834     {
3835         PyThreadState* __tstate = wxPyBeginAllowThreads();
3836         (arg1)->SetTargetWindow(arg2);
3837
3838         wxPyEndAllowThreads(__tstate);
3839         if (PyErr_Occurred()) SWIG_fail;
3840     }
3841     Py_INCREF(Py_None); resultobj = Py_None;
3842     return resultobj;
3843     fail:
3844     return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_ScrolledWindow_GetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3849     PyObject *resultobj;
3850     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3851     wxWindow *result;
3852     PyObject * obj0 = 0 ;
3853     char *kwnames[] = {
3854         (char *) "self", NULL
3855     };
3856
3857     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetWindow",kwnames,&obj0)) goto fail;
3858     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3859     if (SWIG_arg_fail(1)) SWIG_fail;
3860     {
3861         PyThreadState* __tstate = wxPyBeginAllowThreads();
3862         result = (wxWindow *)((wxScrolledWindow const *)arg1)->GetTargetWindow();
3863
3864         wxPyEndAllowThreads(__tstate);
3865         if (PyErr_Occurred()) SWIG_fail;
3866     }
3867     {
3868         resultobj = wxPyMake_wxObject(result, 0);
3869     }
3870     return resultobj;
3871     fail:
3872     return NULL;
3873 }
3874
3875
3876 static PyObject *_wrap_ScrolledWindow_SetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3877     PyObject *resultobj;
3878     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3879     wxRect *arg2 = 0 ;
3880     wxRect temp2 ;
3881     PyObject * obj0 = 0 ;
3882     PyObject * obj1 = 0 ;
3883     char *kwnames[] = {
3884         (char *) "self",(char *) "rect", NULL
3885     };
3886
3887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetRect",kwnames,&obj0,&obj1)) goto fail;
3888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3889     if (SWIG_arg_fail(1)) SWIG_fail;
3890     {
3891         arg2 = &temp2;
3892         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3893     }
3894     {
3895         PyThreadState* __tstate = wxPyBeginAllowThreads();
3896         (arg1)->SetTargetRect((wxRect const &)*arg2);
3897
3898         wxPyEndAllowThreads(__tstate);
3899         if (PyErr_Occurred()) SWIG_fail;
3900     }
3901     Py_INCREF(Py_None); resultobj = Py_None;
3902     return resultobj;
3903     fail:
3904     return NULL;
3905 }
3906
3907
3908 static PyObject *_wrap_ScrolledWindow_GetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3909     PyObject *resultobj;
3910     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3911     wxRect result;
3912     PyObject * obj0 = 0 ;
3913     char *kwnames[] = {
3914         (char *) "self", NULL
3915     };
3916
3917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetRect",kwnames,&obj0)) goto fail;
3918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3919     if (SWIG_arg_fail(1)) SWIG_fail;
3920     {
3921         PyThreadState* __tstate = wxPyBeginAllowThreads();
3922         result = ((wxScrolledWindow const *)arg1)->GetTargetRect();
3923
3924         wxPyEndAllowThreads(__tstate);
3925         if (PyErr_Occurred()) SWIG_fail;
3926     }
3927     {
3928         wxRect * resultptr;
3929         resultptr = new wxRect((wxRect &)(result));
3930         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
3931     }
3932     return resultobj;
3933     fail:
3934     return NULL;
3935 }
3936
3937
3938 static PyObject *_wrap_ScrolledWindow_DoPrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
3939     PyObject *resultobj;
3940     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3941     wxDC *arg2 = 0 ;
3942     PyObject * obj0 = 0 ;
3943     PyObject * obj1 = 0 ;
3944     char *kwnames[] = {
3945         (char *) "self",(char *) "dc", NULL
3946     };
3947
3948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_DoPrepareDC",kwnames,&obj0,&obj1)) goto fail;
3949     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3950     if (SWIG_arg_fail(1)) SWIG_fail;
3951     {
3952         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3953         if (SWIG_arg_fail(2)) SWIG_fail;
3954         if (arg2 == NULL) {
3955             SWIG_null_ref("wxDC");
3956         }
3957         if (SWIG_arg_fail(2)) SWIG_fail;
3958     }
3959     {
3960         PyThreadState* __tstate = wxPyBeginAllowThreads();
3961         (arg1)->DoPrepareDC(*arg2);
3962
3963         wxPyEndAllowThreads(__tstate);
3964         if (PyErr_Occurred()) SWIG_fail;
3965     }
3966     Py_INCREF(Py_None); resultobj = Py_None;
3967     return resultobj;
3968     fail:
3969     return NULL;
3970 }
3971
3972
3973 static PyObject *_wrap_ScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3974     PyObject *resultobj;
3975     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3976     wxVisualAttributes result;
3977     PyObject * obj0 = 0 ;
3978     char *kwnames[] = {
3979         (char *) "variant", NULL
3980     };
3981
3982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrolledWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3983     if (obj0) {
3984         {
3985             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
3986             if (SWIG_arg_fail(1)) SWIG_fail;
3987         }
3988     }
3989     {
3990         if (!wxPyCheckForApp()) SWIG_fail;
3991         PyThreadState* __tstate = wxPyBeginAllowThreads();
3992         result = wxScrolledWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
3993
3994         wxPyEndAllowThreads(__tstate);
3995         if (PyErr_Occurred()) SWIG_fail;
3996     }
3997     {
3998         wxVisualAttributes * resultptr;
3999         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
4000         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
4001     }
4002     return resultobj;
4003     fail:
4004     return NULL;
4005 }
4006
4007
4008 static PyObject * ScrolledWindow_swigregister(PyObject *, PyObject *args) {
4009     PyObject *obj;
4010     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4011     SWIG_TypeClientData(SWIGTYPE_p_wxScrolledWindow, obj);
4012     Py_INCREF(obj);
4013     return Py_BuildValue((char *)"");
4014 }
4015 static int _wrap_FrameNameStr_set(PyObject *) {
4016     PyErr_SetString(PyExc_TypeError,"Variable FrameNameStr is read-only.");
4017     return 1;
4018 }
4019
4020
4021 static PyObject *_wrap_FrameNameStr_get(void) {
4022     PyObject *pyobj;
4023
4024     {
4025 #if wxUSE_UNICODE
4026         pyobj = PyUnicode_FromWideChar((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4027 #else
4028         pyobj = PyString_FromStringAndSize((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4029 #endif
4030     }
4031     return pyobj;
4032 }
4033
4034
4035 static int _wrap_DialogNameStr_set(PyObject *) {
4036     PyErr_SetString(PyExc_TypeError,"Variable DialogNameStr is read-only.");
4037     return 1;
4038 }
4039
4040
4041 static PyObject *_wrap_DialogNameStr_get(void) {
4042     PyObject *pyobj;
4043
4044     {
4045 #if wxUSE_UNICODE
4046         pyobj = PyUnicode_FromWideChar((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4047 #else
4048         pyobj = PyString_FromStringAndSize((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4049 #endif
4050     }
4051     return pyobj;
4052 }
4053
4054
4055 static int _wrap_StatusLineNameStr_set(PyObject *) {
4056     PyErr_SetString(PyExc_TypeError,"Variable StatusLineNameStr is read-only.");
4057     return 1;
4058 }
4059
4060
4061 static PyObject *_wrap_StatusLineNameStr_get(void) {
4062     PyObject *pyobj;
4063
4064     {
4065 #if wxUSE_UNICODE
4066         pyobj = PyUnicode_FromWideChar((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4067 #else
4068         pyobj = PyString_FromStringAndSize((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4069 #endif
4070     }
4071     return pyobj;
4072 }
4073
4074
4075 static int _wrap_ToolBarNameStr_set(PyObject *) {
4076     PyErr_SetString(PyExc_TypeError,"Variable ToolBarNameStr is read-only.");
4077     return 1;
4078 }
4079
4080
4081 static PyObject *_wrap_ToolBarNameStr_get(void) {
4082     PyObject *pyobj;
4083
4084     {
4085 #if wxUSE_UNICODE
4086         pyobj = PyUnicode_FromWideChar((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4087 #else
4088         pyobj = PyString_FromStringAndSize((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4089 #endif
4090     }
4091     return pyobj;
4092 }
4093
4094
4095 static PyObject *_wrap_TopLevelWindow_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
4096     PyObject *resultobj;
4097     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4098     bool arg2 = (bool) true ;
4099     PyObject * obj0 = 0 ;
4100     PyObject * obj1 = 0 ;
4101     char *kwnames[] = {
4102         (char *) "self",(char *) "maximize", NULL
4103     };
4104
4105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Maximize",kwnames,&obj0,&obj1)) goto fail;
4106     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4107     if (SWIG_arg_fail(1)) SWIG_fail;
4108     if (obj1) {
4109         {
4110             arg2 = (bool)(SWIG_As_bool(obj1));
4111             if (SWIG_arg_fail(2)) SWIG_fail;
4112         }
4113     }
4114     {
4115         PyThreadState* __tstate = wxPyBeginAllowThreads();
4116         (arg1)->Maximize(arg2);
4117
4118         wxPyEndAllowThreads(__tstate);
4119         if (PyErr_Occurred()) SWIG_fail;
4120     }
4121     Py_INCREF(Py_None); resultobj = Py_None;
4122     return resultobj;
4123     fail:
4124     return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_TopLevelWindow_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
4129     PyObject *resultobj;
4130     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4131     PyObject * obj0 = 0 ;
4132     char *kwnames[] = {
4133         (char *) "self", NULL
4134     };
4135
4136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_Restore",kwnames,&obj0)) goto fail;
4137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4138     if (SWIG_arg_fail(1)) SWIG_fail;
4139     {
4140         PyThreadState* __tstate = wxPyBeginAllowThreads();
4141         (arg1)->Restore();
4142
4143         wxPyEndAllowThreads(__tstate);
4144         if (PyErr_Occurred()) SWIG_fail;
4145     }
4146     Py_INCREF(Py_None); resultobj = Py_None;
4147     return resultobj;
4148     fail:
4149     return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_TopLevelWindow_Iconize(PyObject *, PyObject *args, PyObject *kwargs) {
4154     PyObject *resultobj;
4155     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4156     bool arg2 = (bool) true ;
4157     PyObject * obj0 = 0 ;
4158     PyObject * obj1 = 0 ;
4159     char *kwnames[] = {
4160         (char *) "self",(char *) "iconize", NULL
4161     };
4162
4163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Iconize",kwnames,&obj0,&obj1)) goto fail;
4164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4165     if (SWIG_arg_fail(1)) SWIG_fail;
4166     if (obj1) {
4167         {
4168             arg2 = (bool)(SWIG_As_bool(obj1));
4169             if (SWIG_arg_fail(2)) SWIG_fail;
4170         }
4171     }
4172     {
4173         PyThreadState* __tstate = wxPyBeginAllowThreads();
4174         (arg1)->Iconize(arg2);
4175
4176         wxPyEndAllowThreads(__tstate);
4177         if (PyErr_Occurred()) SWIG_fail;
4178     }
4179     Py_INCREF(Py_None); resultobj = Py_None;
4180     return resultobj;
4181     fail:
4182     return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_TopLevelWindow_IsMaximized(PyObject *, PyObject *args, PyObject *kwargs) {
4187     PyObject *resultobj;
4188     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4189     bool result;
4190     PyObject * obj0 = 0 ;
4191     char *kwnames[] = {
4192         (char *) "self", NULL
4193     };
4194
4195     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsMaximized",kwnames,&obj0)) goto fail;
4196     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4197     if (SWIG_arg_fail(1)) SWIG_fail;
4198     {
4199         PyThreadState* __tstate = wxPyBeginAllowThreads();
4200         result = (bool)((wxTopLevelWindow const *)arg1)->IsMaximized();
4201
4202         wxPyEndAllowThreads(__tstate);
4203         if (PyErr_Occurred()) SWIG_fail;
4204     }
4205     {
4206         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4207     }
4208     return resultobj;
4209     fail:
4210     return NULL;
4211 }
4212
4213
4214 static PyObject *_wrap_TopLevelWindow_IsIconized(PyObject *, PyObject *args, PyObject *kwargs) {
4215     PyObject *resultobj;
4216     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4217     bool result;
4218     PyObject * obj0 = 0 ;
4219     char *kwnames[] = {
4220         (char *) "self", NULL
4221     };
4222
4223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsIconized",kwnames,&obj0)) goto fail;
4224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4225     if (SWIG_arg_fail(1)) SWIG_fail;
4226     {
4227         PyThreadState* __tstate = wxPyBeginAllowThreads();
4228         result = (bool)((wxTopLevelWindow const *)arg1)->IsIconized();
4229
4230         wxPyEndAllowThreads(__tstate);
4231         if (PyErr_Occurred()) SWIG_fail;
4232     }
4233     {
4234         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4235     }
4236     return resultobj;
4237     fail:
4238     return NULL;
4239 }
4240
4241
4242 static PyObject *_wrap_TopLevelWindow_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4243     PyObject *resultobj;
4244     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4245     wxIcon result;
4246     PyObject * obj0 = 0 ;
4247     char *kwnames[] = {
4248         (char *) "self", NULL
4249     };
4250
4251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetIcon",kwnames,&obj0)) goto fail;
4252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4253     if (SWIG_arg_fail(1)) SWIG_fail;
4254     {
4255         PyThreadState* __tstate = wxPyBeginAllowThreads();
4256         result = ((wxTopLevelWindow const *)arg1)->GetIcon();
4257
4258         wxPyEndAllowThreads(__tstate);
4259         if (PyErr_Occurred()) SWIG_fail;
4260     }
4261     {
4262         wxIcon * resultptr;
4263         resultptr = new wxIcon((wxIcon &)(result));
4264         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
4265     }
4266     return resultobj;
4267     fail:
4268     return NULL;
4269 }
4270
4271
4272 static PyObject *_wrap_TopLevelWindow_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4273     PyObject *resultobj;
4274     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4275     wxIcon *arg2 = 0 ;
4276     PyObject * obj0 = 0 ;
4277     PyObject * obj1 = 0 ;
4278     char *kwnames[] = {
4279         (char *) "self",(char *) "icon", NULL
4280     };
4281
4282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcon",kwnames,&obj0,&obj1)) goto fail;
4283     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4284     if (SWIG_arg_fail(1)) SWIG_fail;
4285     {
4286         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4287         if (SWIG_arg_fail(2)) SWIG_fail;
4288         if (arg2 == NULL) {
4289             SWIG_null_ref("wxIcon");
4290         }
4291         if (SWIG_arg_fail(2)) SWIG_fail;
4292     }
4293     {
4294         PyThreadState* __tstate = wxPyBeginAllowThreads();
4295         (arg1)->SetIcon((wxIcon const &)*arg2);
4296
4297         wxPyEndAllowThreads(__tstate);
4298         if (PyErr_Occurred()) SWIG_fail;
4299     }
4300     Py_INCREF(Py_None); resultobj = Py_None;
4301     return resultobj;
4302     fail:
4303     return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_TopLevelWindow_SetIcons(PyObject *, PyObject *args, PyObject *kwargs) {
4308     PyObject *resultobj;
4309     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4310     wxIconBundle *arg2 = 0 ;
4311     PyObject * obj0 = 0 ;
4312     PyObject * obj1 = 0 ;
4313     char *kwnames[] = {
4314         (char *) "self",(char *) "icons", NULL
4315     };
4316
4317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcons",kwnames,&obj0,&obj1)) goto fail;
4318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4319     if (SWIG_arg_fail(1)) SWIG_fail;
4320     {
4321         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
4322         if (SWIG_arg_fail(2)) SWIG_fail;
4323         if (arg2 == NULL) {
4324             SWIG_null_ref("wxIconBundle");
4325         }
4326         if (SWIG_arg_fail(2)) SWIG_fail;
4327     }
4328     {
4329         PyThreadState* __tstate = wxPyBeginAllowThreads();
4330         (arg1)->SetIcons((wxIconBundle const &)*arg2);
4331
4332         wxPyEndAllowThreads(__tstate);
4333         if (PyErr_Occurred()) SWIG_fail;
4334     }
4335     Py_INCREF(Py_None); resultobj = Py_None;
4336     return resultobj;
4337     fail:
4338     return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_TopLevelWindow_ShowFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4343     PyObject *resultobj;
4344     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4345     bool arg2 ;
4346     long arg3 = (long) wxFULLSCREEN_ALL ;
4347     bool result;
4348     PyObject * obj0 = 0 ;
4349     PyObject * obj1 = 0 ;
4350     PyObject * obj2 = 0 ;
4351     char *kwnames[] = {
4352         (char *) "self",(char *) "show",(char *) "style", NULL
4353     };
4354
4355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TopLevelWindow_ShowFullScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
4356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4357     if (SWIG_arg_fail(1)) SWIG_fail;
4358     {
4359         arg2 = (bool)(SWIG_As_bool(obj1));
4360         if (SWIG_arg_fail(2)) SWIG_fail;
4361     }
4362     if (obj2) {
4363         {
4364             arg3 = (long)(SWIG_As_long(obj2));
4365             if (SWIG_arg_fail(3)) SWIG_fail;
4366         }
4367     }
4368     {
4369         PyThreadState* __tstate = wxPyBeginAllowThreads();
4370         result = (bool)(arg1)->ShowFullScreen(arg2,arg3);
4371
4372         wxPyEndAllowThreads(__tstate);
4373         if (PyErr_Occurred()) SWIG_fail;
4374     }
4375     {
4376         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4377     }
4378     return resultobj;
4379     fail:
4380     return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_TopLevelWindow_IsFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4385     PyObject *resultobj;
4386     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4387     bool result;
4388     PyObject * obj0 = 0 ;
4389     char *kwnames[] = {
4390         (char *) "self", NULL
4391     };
4392
4393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsFullScreen",kwnames,&obj0)) goto fail;
4394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4395     if (SWIG_arg_fail(1)) SWIG_fail;
4396     {
4397         PyThreadState* __tstate = wxPyBeginAllowThreads();
4398         result = (bool)((wxTopLevelWindow const *)arg1)->IsFullScreen();
4399
4400         wxPyEndAllowThreads(__tstate);
4401         if (PyErr_Occurred()) SWIG_fail;
4402     }
4403     {
4404         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4405     }
4406     return resultobj;
4407     fail:
4408     return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_TopLevelWindow_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4413     PyObject *resultobj;
4414     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4415     wxString *arg2 = 0 ;
4416     bool temp2 = false ;
4417     PyObject * obj0 = 0 ;
4418     PyObject * obj1 = 0 ;
4419     char *kwnames[] = {
4420         (char *) "self",(char *) "title", NULL
4421     };
4422
4423     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetTitle",kwnames,&obj0,&obj1)) goto fail;
4424     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4425     if (SWIG_arg_fail(1)) SWIG_fail;
4426     {
4427         arg2 = wxString_in_helper(obj1);
4428         if (arg2 == NULL) SWIG_fail;
4429         temp2 = true;
4430     }
4431     {
4432         PyThreadState* __tstate = wxPyBeginAllowThreads();
4433         (arg1)->SetTitle((wxString const &)*arg2);
4434
4435         wxPyEndAllowThreads(__tstate);
4436         if (PyErr_Occurred()) SWIG_fail;
4437     }
4438     Py_INCREF(Py_None); resultobj = Py_None;
4439     {
4440         if (temp2)
4441         delete arg2;
4442     }
4443     return resultobj;
4444     fail:
4445     {
4446         if (temp2)
4447         delete arg2;
4448     }
4449     return NULL;
4450 }
4451
4452
4453 static PyObject *_wrap_TopLevelWindow_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4454     PyObject *resultobj;
4455     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4456     wxString result;
4457     PyObject * obj0 = 0 ;
4458     char *kwnames[] = {
4459         (char *) "self", NULL
4460     };
4461
4462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetTitle",kwnames,&obj0)) goto fail;
4463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4464     if (SWIG_arg_fail(1)) SWIG_fail;
4465     {
4466         PyThreadState* __tstate = wxPyBeginAllowThreads();
4467         result = ((wxTopLevelWindow const *)arg1)->GetTitle();
4468
4469         wxPyEndAllowThreads(__tstate);
4470         if (PyErr_Occurred()) SWIG_fail;
4471     }
4472     {
4473 #if wxUSE_UNICODE
4474         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4475 #else
4476         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4477 #endif
4478     }
4479     return resultobj;
4480     fail:
4481     return NULL;
4482 }
4483
4484
4485 static PyObject *_wrap_TopLevelWindow_SetShape(PyObject *, PyObject *args, PyObject *kwargs) {
4486     PyObject *resultobj;
4487     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4488     wxRegion *arg2 = 0 ;
4489     bool result;
4490     PyObject * obj0 = 0 ;
4491     PyObject * obj1 = 0 ;
4492     char *kwnames[] = {
4493         (char *) "self",(char *) "region", NULL
4494     };
4495
4496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetShape",kwnames,&obj0,&obj1)) goto fail;
4497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4498     if (SWIG_arg_fail(1)) SWIG_fail;
4499     {
4500         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
4501         if (SWIG_arg_fail(2)) SWIG_fail;
4502         if (arg2 == NULL) {
4503             SWIG_null_ref("wxRegion");
4504         }
4505         if (SWIG_arg_fail(2)) SWIG_fail;
4506     }
4507     {
4508         PyThreadState* __tstate = wxPyBeginAllowThreads();
4509         result = (bool)(arg1)->SetShape((wxRegion const &)*arg2);
4510
4511         wxPyEndAllowThreads(__tstate);
4512         if (PyErr_Occurred()) SWIG_fail;
4513     }
4514     {
4515         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516     }
4517     return resultobj;
4518     fail:
4519     return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_TopLevelWindow_RequestUserAttention(PyObject *, PyObject *args, PyObject *kwargs) {
4524     PyObject *resultobj;
4525     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4526     int arg2 = (int) wxUSER_ATTENTION_INFO ;
4527     PyObject * obj0 = 0 ;
4528     PyObject * obj1 = 0 ;
4529     char *kwnames[] = {
4530         (char *) "self",(char *) "flags", NULL
4531     };
4532
4533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_RequestUserAttention",kwnames,&obj0,&obj1)) goto fail;
4534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4535     if (SWIG_arg_fail(1)) SWIG_fail;
4536     if (obj1) {
4537         {
4538             arg2 = (int)(SWIG_As_int(obj1));
4539             if (SWIG_arg_fail(2)) SWIG_fail;
4540         }
4541     }
4542     {
4543         PyThreadState* __tstate = wxPyBeginAllowThreads();
4544         (arg1)->RequestUserAttention(arg2);
4545
4546         wxPyEndAllowThreads(__tstate);
4547         if (PyErr_Occurred()) SWIG_fail;
4548     }
4549     Py_INCREF(Py_None); resultobj = Py_None;
4550     return resultobj;
4551     fail:
4552     return NULL;
4553 }
4554
4555
4556 static PyObject *_wrap_TopLevelWindow_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
4557     PyObject *resultobj;
4558     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4559     bool result;
4560     PyObject * obj0 = 0 ;
4561     char *kwnames[] = {
4562         (char *) "self", NULL
4563     };
4564
4565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsActive",kwnames,&obj0)) goto fail;
4566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4567     if (SWIG_arg_fail(1)) SWIG_fail;
4568     {
4569         PyThreadState* __tstate = wxPyBeginAllowThreads();
4570         result = (bool)(arg1)->IsActive();
4571
4572         wxPyEndAllowThreads(__tstate);
4573         if (PyErr_Occurred()) SWIG_fail;
4574     }
4575     {
4576         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4577     }
4578     return resultobj;
4579     fail:
4580     return NULL;
4581 }
4582
4583
4584 static PyObject *_wrap_TopLevelWindow_MacSetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4585     PyObject *resultobj;
4586     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4587     bool arg2 ;
4588     PyObject * obj0 = 0 ;
4589     PyObject * obj1 = 0 ;
4590     char *kwnames[] = {
4591         (char *) "self",(char *) "on", NULL
4592     };
4593
4594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_MacSetMetalAppearance",kwnames,&obj0,&obj1)) goto fail;
4595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4596     if (SWIG_arg_fail(1)) SWIG_fail;
4597     {
4598         arg2 = (bool)(SWIG_As_bool(obj1));
4599         if (SWIG_arg_fail(2)) SWIG_fail;
4600     }
4601     {
4602         PyThreadState* __tstate = wxPyBeginAllowThreads();
4603         wxTopLevelWindow_MacSetMetalAppearance(arg1,arg2);
4604
4605         wxPyEndAllowThreads(__tstate);
4606         if (PyErr_Occurred()) SWIG_fail;
4607     }
4608     Py_INCREF(Py_None); resultobj = Py_None;
4609     return resultobj;
4610     fail:
4611     return NULL;
4612 }
4613
4614
4615 static PyObject *_wrap_TopLevelWindow_MacGetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4616     PyObject *resultobj;
4617     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4618     bool result;
4619     PyObject * obj0 = 0 ;
4620     char *kwnames[] = {
4621         (char *) "self", NULL
4622     };
4623
4624     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_MacGetMetalAppearance",kwnames,&obj0)) goto fail;
4625     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4626     if (SWIG_arg_fail(1)) SWIG_fail;
4627     {
4628         PyThreadState* __tstate = wxPyBeginAllowThreads();
4629         result = (bool)wxTopLevelWindow_MacGetMetalAppearance((wxTopLevelWindow const *)arg1);
4630
4631         wxPyEndAllowThreads(__tstate);
4632         if (PyErr_Occurred()) SWIG_fail;
4633     }
4634     {
4635         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636     }
4637     return resultobj;
4638     fail:
4639     return NULL;
4640 }
4641
4642
4643 static PyObject * TopLevelWindow_swigregister(PyObject *, PyObject *args) {
4644     PyObject *obj;
4645     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4646     SWIG_TypeClientData(SWIGTYPE_p_wxTopLevelWindow, obj);
4647     Py_INCREF(obj);
4648     return Py_BuildValue((char *)"");
4649 }
4650 static PyObject *_wrap_new_Frame(PyObject *, PyObject *args, PyObject *kwargs) {
4651     PyObject *resultobj;
4652     wxWindow *arg1 = (wxWindow *) 0 ;
4653     int arg2 = (int) (int)-1 ;
4654     wxString const &arg3_defvalue = wxPyEmptyString ;
4655     wxString *arg3 = (wxString *) &arg3_defvalue ;
4656     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4657     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4658     wxSize const &arg5_defvalue = wxDefaultSize ;
4659     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4660     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
4661     wxString const &arg7_defvalue = wxPyFrameNameStr ;
4662     wxString *arg7 = (wxString *) &arg7_defvalue ;
4663     wxFrame *result;
4664     bool temp3 = false ;
4665     wxPoint temp4 ;
4666     wxSize temp5 ;
4667     bool temp7 = false ;
4668     PyObject * obj0 = 0 ;
4669     PyObject * obj1 = 0 ;
4670     PyObject * obj2 = 0 ;
4671     PyObject * obj3 = 0 ;
4672     PyObject * obj4 = 0 ;
4673     PyObject * obj5 = 0 ;
4674     PyObject * obj6 = 0 ;
4675     char *kwnames[] = {
4676         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4677     };
4678
4679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Frame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4680     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4681     if (SWIG_arg_fail(1)) SWIG_fail;
4682     if (obj1) {
4683         {
4684             arg2 = (int const)(SWIG_As_int(obj1));
4685             if (SWIG_arg_fail(2)) SWIG_fail;
4686         }
4687     }
4688     if (obj2) {
4689         {
4690             arg3 = wxString_in_helper(obj2);
4691             if (arg3 == NULL) SWIG_fail;
4692             temp3 = true;
4693         }
4694     }
4695     if (obj3) {
4696         {
4697             arg4 = &temp4;
4698             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4699         }
4700     }
4701     if (obj4) {
4702         {
4703             arg5 = &temp5;
4704             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4705         }
4706     }
4707     if (obj5) {
4708         {
4709             arg6 = (long)(SWIG_As_long(obj5));
4710             if (SWIG_arg_fail(6)) SWIG_fail;
4711         }
4712     }
4713     if (obj6) {
4714         {
4715             arg7 = wxString_in_helper(obj6);
4716             if (arg7 == NULL) SWIG_fail;
4717             temp7 = true;
4718         }
4719     }
4720     {
4721         if (!wxPyCheckForApp()) SWIG_fail;
4722         PyThreadState* __tstate = wxPyBeginAllowThreads();
4723         result = (wxFrame *)new wxFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
4724
4725         wxPyEndAllowThreads(__tstate);
4726         if (PyErr_Occurred()) SWIG_fail;
4727     }
4728     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4729     {
4730         if (temp3)
4731         delete arg3;
4732     }
4733     {
4734         if (temp7)
4735         delete arg7;
4736     }
4737     return resultobj;
4738     fail:
4739     {
4740         if (temp3)
4741         delete arg3;
4742     }
4743     {
4744         if (temp7)
4745         delete arg7;
4746     }
4747     return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_new_PreFrame(PyObject *, PyObject *args, PyObject *kwargs) {
4752     PyObject *resultobj;
4753     wxFrame *result;
4754     char *kwnames[] = {
4755         NULL
4756     };
4757
4758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFrame",kwnames)) goto fail;
4759     {
4760         if (!wxPyCheckForApp()) SWIG_fail;
4761         PyThreadState* __tstate = wxPyBeginAllowThreads();
4762         result = (wxFrame *)new wxFrame();
4763
4764         wxPyEndAllowThreads(__tstate);
4765         if (PyErr_Occurred()) SWIG_fail;
4766     }
4767     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4768     return resultobj;
4769     fail:
4770     return NULL;
4771 }
4772
4773
4774 static PyObject *_wrap_Frame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4775     PyObject *resultobj;
4776     wxFrame *arg1 = (wxFrame *) 0 ;
4777     wxWindow *arg2 = (wxWindow *) 0 ;
4778     int arg3 = (int) (int)-1 ;
4779     wxString const &arg4_defvalue = wxPyEmptyString ;
4780     wxString *arg4 = (wxString *) &arg4_defvalue ;
4781     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4782     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4783     wxSize const &arg6_defvalue = wxDefaultSize ;
4784     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4785     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
4786     wxString const &arg8_defvalue = wxPyFrameNameStr ;
4787     wxString *arg8 = (wxString *) &arg8_defvalue ;
4788     bool result;
4789     bool temp4 = false ;
4790     wxPoint temp5 ;
4791     wxSize temp6 ;
4792     bool temp8 = false ;
4793     PyObject * obj0 = 0 ;
4794     PyObject * obj1 = 0 ;
4795     PyObject * obj2 = 0 ;
4796     PyObject * obj3 = 0 ;
4797     PyObject * obj4 = 0 ;
4798     PyObject * obj5 = 0 ;
4799     PyObject * obj6 = 0 ;
4800     PyObject * obj7 = 0 ;
4801     char *kwnames[] = {
4802         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4803     };
4804
4805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Frame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4806     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4807     if (SWIG_arg_fail(1)) SWIG_fail;
4808     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4809     if (SWIG_arg_fail(2)) SWIG_fail;
4810     if (obj2) {
4811         {
4812             arg3 = (int const)(SWIG_As_int(obj2));
4813             if (SWIG_arg_fail(3)) SWIG_fail;
4814         }
4815     }
4816     if (obj3) {
4817         {
4818             arg4 = wxString_in_helper(obj3);
4819             if (arg4 == NULL) SWIG_fail;
4820             temp4 = true;
4821         }
4822     }
4823     if (obj4) {
4824         {
4825             arg5 = &temp5;
4826             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4827         }
4828     }
4829     if (obj5) {
4830         {
4831             arg6 = &temp6;
4832             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4833         }
4834     }
4835     if (obj6) {
4836         {
4837             arg7 = (long)(SWIG_As_long(obj6));
4838             if (SWIG_arg_fail(7)) SWIG_fail;
4839         }
4840     }
4841     if (obj7) {
4842         {
4843             arg8 = wxString_in_helper(obj7);
4844             if (arg8 == NULL) SWIG_fail;
4845             temp8 = true;
4846         }
4847     }
4848     {
4849         PyThreadState* __tstate = wxPyBeginAllowThreads();
4850         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
4851
4852         wxPyEndAllowThreads(__tstate);
4853         if (PyErr_Occurred()) SWIG_fail;
4854     }
4855     {
4856         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4857     }
4858     {
4859         if (temp4)
4860         delete arg4;
4861     }
4862     {
4863         if (temp8)
4864         delete arg8;
4865     }
4866     return resultobj;
4867     fail:
4868     {
4869         if (temp4)
4870         delete arg4;
4871     }
4872     {
4873         if (temp8)
4874         delete arg8;
4875     }
4876     return NULL;
4877 }
4878
4879
4880 static PyObject *_wrap_Frame_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
4881     PyObject *resultobj;
4882     wxFrame *arg1 = (wxFrame *) 0 ;
4883     wxPoint result;
4884     PyObject * obj0 = 0 ;
4885     char *kwnames[] = {
4886         (char *) "self", NULL
4887     };
4888
4889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
4890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4891     if (SWIG_arg_fail(1)) SWIG_fail;
4892     {
4893         PyThreadState* __tstate = wxPyBeginAllowThreads();
4894         result = ((wxFrame const *)arg1)->GetClientAreaOrigin();
4895
4896         wxPyEndAllowThreads(__tstate);
4897         if (PyErr_Occurred()) SWIG_fail;
4898     }
4899     {
4900         wxPoint * resultptr;
4901         resultptr = new wxPoint((wxPoint &)(result));
4902         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4903     }
4904     return resultobj;
4905     fail:
4906     return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_Frame_SendSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
4911     PyObject *resultobj;
4912     wxFrame *arg1 = (wxFrame *) 0 ;
4913     PyObject * obj0 = 0 ;
4914     char *kwnames[] = {
4915         (char *) "self", NULL
4916     };
4917
4918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_SendSizeEvent",kwnames,&obj0)) goto fail;
4919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4920     if (SWIG_arg_fail(1)) SWIG_fail;
4921     {
4922         PyThreadState* __tstate = wxPyBeginAllowThreads();
4923         (arg1)->SendSizeEvent();
4924
4925         wxPyEndAllowThreads(__tstate);
4926         if (PyErr_Occurred()) SWIG_fail;
4927     }
4928     Py_INCREF(Py_None); resultobj = Py_None;
4929     return resultobj;
4930     fail:
4931     return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_Frame_SetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4936     PyObject *resultobj;
4937     wxFrame *arg1 = (wxFrame *) 0 ;
4938     wxMenuBar *arg2 = (wxMenuBar *) 0 ;
4939     PyObject * obj0 = 0 ;
4940     PyObject * obj1 = 0 ;
4941     char *kwnames[] = {
4942         (char *) "self",(char *) "menubar", NULL
4943     };
4944
4945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetMenuBar",kwnames,&obj0,&obj1)) goto fail;
4946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4947     if (SWIG_arg_fail(1)) SWIG_fail;
4948     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
4949     if (SWIG_arg_fail(2)) SWIG_fail;
4950     {
4951         PyThreadState* __tstate = wxPyBeginAllowThreads();
4952         (arg1)->SetMenuBar(arg2);
4953
4954         wxPyEndAllowThreads(__tstate);
4955         if (PyErr_Occurred()) SWIG_fail;
4956     }
4957     Py_INCREF(Py_None); resultobj = Py_None;
4958     return resultobj;
4959     fail:
4960     return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Frame_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4965     PyObject *resultobj;
4966     wxFrame *arg1 = (wxFrame *) 0 ;
4967     wxMenuBar *result;
4968     PyObject * obj0 = 0 ;
4969     char *kwnames[] = {
4970         (char *) "self", NULL
4971     };
4972
4973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetMenuBar",kwnames,&obj0)) goto fail;
4974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4975     if (SWIG_arg_fail(1)) SWIG_fail;
4976     {
4977         PyThreadState* __tstate = wxPyBeginAllowThreads();
4978         result = (wxMenuBar *)((wxFrame const *)arg1)->GetMenuBar();
4979
4980         wxPyEndAllowThreads(__tstate);
4981         if (PyErr_Occurred()) SWIG_fail;
4982     }
4983     {
4984         resultobj = wxPyMake_wxObject(result, 0);
4985     }
4986     return resultobj;
4987     fail:
4988     return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Frame_ProcessCommand(PyObject *, PyObject *args, PyObject *kwargs) {
4993     PyObject *resultobj;
4994     wxFrame *arg1 = (wxFrame *) 0 ;
4995     int arg2 ;
4996     bool result;
4997     PyObject * obj0 = 0 ;
4998     PyObject * obj1 = 0 ;
4999     char *kwnames[] = {
5000         (char *) "self",(char *) "winid", NULL
5001     };
5002
5003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_ProcessCommand",kwnames,&obj0,&obj1)) goto fail;
5004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5005     if (SWIG_arg_fail(1)) SWIG_fail;
5006     {
5007         arg2 = (int)(SWIG_As_int(obj1));
5008         if (SWIG_arg_fail(2)) SWIG_fail;
5009     }
5010     {
5011         PyThreadState* __tstate = wxPyBeginAllowThreads();
5012         result = (bool)(arg1)->ProcessCommand(arg2);
5013
5014         wxPyEndAllowThreads(__tstate);
5015         if (PyErr_Occurred()) SWIG_fail;
5016     }
5017     {
5018         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5019     }
5020     return resultobj;
5021     fail:
5022     return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_Frame_CreateStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5027     PyObject *resultobj;
5028     wxFrame *arg1 = (wxFrame *) 0 ;
5029     int arg2 = (int) 1 ;
5030     long arg3 = (long) wxDEFAULT_STATUSBAR_STYLE ;
5031     int arg4 = (int) 0 ;
5032     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
5033     wxString *arg5 = (wxString *) &arg5_defvalue ;
5034     wxStatusBar *result;
5035     bool temp5 = false ;
5036     PyObject * obj0 = 0 ;
5037     PyObject * obj1 = 0 ;
5038     PyObject * obj2 = 0 ;
5039     PyObject * obj3 = 0 ;
5040     PyObject * obj4 = 0 ;
5041     char *kwnames[] = {
5042         (char *) "self",(char *) "number",(char *) "style",(char *) "winid",(char *) "name", NULL
5043     };
5044
5045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Frame_CreateStatusBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5047     if (SWIG_arg_fail(1)) SWIG_fail;
5048     if (obj1) {
5049         {
5050             arg2 = (int)(SWIG_As_int(obj1));
5051             if (SWIG_arg_fail(2)) SWIG_fail;
5052         }
5053     }
5054     if (obj2) {
5055         {
5056             arg3 = (long)(SWIG_As_long(obj2));
5057             if (SWIG_arg_fail(3)) SWIG_fail;
5058         }
5059     }
5060     if (obj3) {
5061         {
5062             arg4 = (int)(SWIG_As_int(obj3));
5063             if (SWIG_arg_fail(4)) SWIG_fail;
5064         }
5065     }
5066     if (obj4) {
5067         {
5068             arg5 = wxString_in_helper(obj4);
5069             if (arg5 == NULL) SWIG_fail;
5070             temp5 = true;
5071         }
5072     }
5073     {
5074         PyThreadState* __tstate = wxPyBeginAllowThreads();
5075         result = (wxStatusBar *)(arg1)->CreateStatusBar(arg2,arg3,arg4,(wxString const &)*arg5);
5076
5077         wxPyEndAllowThreads(__tstate);
5078         if (PyErr_Occurred()) SWIG_fail;
5079     }
5080     {
5081         resultobj = wxPyMake_wxObject(result, 0);
5082     }
5083     {
5084         if (temp5)
5085         delete arg5;
5086     }
5087     return resultobj;
5088     fail:
5089     {
5090         if (temp5)
5091         delete arg5;
5092     }
5093     return NULL;
5094 }
5095
5096
5097 static PyObject *_wrap_Frame_GetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5098     PyObject *resultobj;
5099     wxFrame *arg1 = (wxFrame *) 0 ;
5100     wxStatusBar *result;
5101     PyObject * obj0 = 0 ;
5102     char *kwnames[] = {
5103         (char *) "self", NULL
5104     };
5105
5106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBar",kwnames,&obj0)) goto fail;
5107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5108     if (SWIG_arg_fail(1)) SWIG_fail;
5109     {
5110         PyThreadState* __tstate = wxPyBeginAllowThreads();
5111         result = (wxStatusBar *)((wxFrame const *)arg1)->GetStatusBar();
5112
5113         wxPyEndAllowThreads(__tstate);
5114         if (PyErr_Occurred()) SWIG_fail;
5115     }
5116     {
5117         resultobj = wxPyMake_wxObject(result, 0);
5118     }
5119     return resultobj;
5120     fail:
5121     return NULL;
5122 }
5123
5124
5125 static PyObject *_wrap_Frame_SetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5126     PyObject *resultobj;
5127     wxFrame *arg1 = (wxFrame *) 0 ;
5128     wxStatusBar *arg2 = (wxStatusBar *) 0 ;
5129     PyObject * obj0 = 0 ;
5130     PyObject * obj1 = 0 ;
5131     char *kwnames[] = {
5132         (char *) "self",(char *) "statBar", NULL
5133     };
5134
5135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBar",kwnames,&obj0,&obj1)) goto fail;
5136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5137     if (SWIG_arg_fail(1)) SWIG_fail;
5138     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
5139     if (SWIG_arg_fail(2)) SWIG_fail;
5140     {
5141         PyThreadState* __tstate = wxPyBeginAllowThreads();
5142         (arg1)->SetStatusBar(arg2);
5143
5144         wxPyEndAllowThreads(__tstate);
5145         if (PyErr_Occurred()) SWIG_fail;
5146     }
5147     Py_INCREF(Py_None); resultobj = Py_None;
5148     return resultobj;
5149     fail:
5150     return NULL;
5151 }
5152
5153
5154 static PyObject *_wrap_Frame_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5155     PyObject *resultobj;
5156     wxFrame *arg1 = (wxFrame *) 0 ;
5157     wxString *arg2 = 0 ;
5158     int arg3 = (int) 0 ;
5159     bool temp2 = false ;
5160     PyObject * obj0 = 0 ;
5161     PyObject * obj1 = 0 ;
5162     PyObject * obj2 = 0 ;
5163     char *kwnames[] = {
5164         (char *) "self",(char *) "text",(char *) "number", NULL
5165     };
5166
5167     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5168     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5169     if (SWIG_arg_fail(1)) SWIG_fail;
5170     {
5171         arg2 = wxString_in_helper(obj1);
5172         if (arg2 == NULL) SWIG_fail;
5173         temp2 = true;
5174     }
5175     if (obj2) {
5176         {
5177             arg3 = (int)(SWIG_As_int(obj2));
5178             if (SWIG_arg_fail(3)) SWIG_fail;
5179         }
5180     }
5181     {
5182         PyThreadState* __tstate = wxPyBeginAllowThreads();
5183         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
5184
5185         wxPyEndAllowThreads(__tstate);
5186         if (PyErr_Occurred()) SWIG_fail;
5187     }
5188     Py_INCREF(Py_None); resultobj = Py_None;
5189     {
5190         if (temp2)
5191         delete arg2;
5192     }
5193     return resultobj;
5194     fail:
5195     {
5196         if (temp2)
5197         delete arg2;
5198     }
5199     return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_Frame_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
5204     PyObject *resultobj;
5205     wxFrame *arg1 = (wxFrame *) 0 ;
5206     int arg2 ;
5207     int *arg3 = (int *) 0 ;
5208     PyObject * obj0 = 0 ;
5209     PyObject * obj1 = 0 ;
5210     char *kwnames[] = {
5211         (char *) "self",(char *) "widths", NULL
5212     };
5213
5214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
5215     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5216     if (SWIG_arg_fail(1)) SWIG_fail;
5217     {
5218         arg2 = PyList_Size(obj1);
5219         arg3 =  int_LIST_helper(obj1);
5220         if (arg3 == NULL) SWIG_fail;
5221     }
5222     {
5223         PyThreadState* __tstate = wxPyBeginAllowThreads();
5224         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
5225
5226         wxPyEndAllowThreads(__tstate);
5227         if (PyErr_Occurred()) SWIG_fail;
5228     }
5229     Py_INCREF(Py_None); resultobj = Py_None;
5230     {
5231         if (arg3) delete [] arg3;
5232     }
5233     return resultobj;
5234     fail:
5235     {
5236         if (arg3) delete [] arg3;
5237     }
5238     return NULL;
5239 }
5240
5241
5242 static PyObject *_wrap_Frame_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5243     PyObject *resultobj;
5244     wxFrame *arg1 = (wxFrame *) 0 ;
5245     wxString *arg2 = 0 ;
5246     int arg3 = (int) 0 ;
5247     bool temp2 = false ;
5248     PyObject * obj0 = 0 ;
5249     PyObject * obj1 = 0 ;
5250     PyObject * obj2 = 0 ;
5251     char *kwnames[] = {
5252         (char *) "self",(char *) "text",(char *) "number", NULL
5253     };
5254
5255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5257     if (SWIG_arg_fail(1)) SWIG_fail;
5258     {
5259         arg2 = wxString_in_helper(obj1);
5260         if (arg2 == NULL) SWIG_fail;
5261         temp2 = true;
5262     }
5263     if (obj2) {
5264         {
5265             arg3 = (int)(SWIG_As_int(obj2));
5266             if (SWIG_arg_fail(3)) SWIG_fail;
5267         }
5268     }
5269     {
5270         PyThreadState* __tstate = wxPyBeginAllowThreads();
5271         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
5272
5273         wxPyEndAllowThreads(__tstate);
5274         if (PyErr_Occurred()) SWIG_fail;
5275     }
5276     Py_INCREF(Py_None); resultobj = Py_None;
5277     {
5278         if (temp2)
5279         delete arg2;
5280     }
5281     return resultobj;
5282     fail:
5283     {
5284         if (temp2)
5285         delete arg2;
5286     }
5287     return NULL;
5288 }
5289
5290
5291 static PyObject *_wrap_Frame_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5292     PyObject *resultobj;
5293     wxFrame *arg1 = (wxFrame *) 0 ;
5294     int arg2 = (int) 0 ;
5295     PyObject * obj0 = 0 ;
5296     PyObject * obj1 = 0 ;
5297     char *kwnames[] = {
5298         (char *) "self",(char *) "number", NULL
5299     };
5300
5301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
5302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5303     if (SWIG_arg_fail(1)) SWIG_fail;
5304     if (obj1) {
5305         {
5306             arg2 = (int)(SWIG_As_int(obj1));
5307             if (SWIG_arg_fail(2)) SWIG_fail;
5308         }
5309     }
5310     {
5311         PyThreadState* __tstate = wxPyBeginAllowThreads();
5312         (arg1)->PopStatusText(arg2);
5313
5314         wxPyEndAllowThreads(__tstate);
5315         if (PyErr_Occurred()) SWIG_fail;
5316     }
5317     Py_INCREF(Py_None); resultobj = Py_None;
5318     return resultobj;
5319     fail:
5320     return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Frame_SetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5325     PyObject *resultobj;
5326     wxFrame *arg1 = (wxFrame *) 0 ;
5327     int arg2 ;
5328     PyObject * obj0 = 0 ;
5329     PyObject * obj1 = 0 ;
5330     char *kwnames[] = {
5331         (char *) "self",(char *) "n", NULL
5332     };
5333
5334     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBarPane",kwnames,&obj0,&obj1)) goto fail;
5335     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5336     if (SWIG_arg_fail(1)) SWIG_fail;
5337     {
5338         arg2 = (int)(SWIG_As_int(obj1));
5339         if (SWIG_arg_fail(2)) SWIG_fail;
5340     }
5341     {
5342         PyThreadState* __tstate = wxPyBeginAllowThreads();
5343         (arg1)->SetStatusBarPane(arg2);
5344
5345         wxPyEndAllowThreads(__tstate);
5346         if (PyErr_Occurred()) SWIG_fail;
5347     }
5348     Py_INCREF(Py_None); resultobj = Py_None;
5349     return resultobj;
5350     fail:
5351     return NULL;
5352 }
5353
5354
5355 static PyObject *_wrap_Frame_GetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5356     PyObject *resultobj;
5357     wxFrame *arg1 = (wxFrame *) 0 ;
5358     int result;
5359     PyObject * obj0 = 0 ;
5360     char *kwnames[] = {
5361         (char *) "self", NULL
5362     };
5363
5364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBarPane",kwnames,&obj0)) goto fail;
5365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5366     if (SWIG_arg_fail(1)) SWIG_fail;
5367     {
5368         PyThreadState* __tstate = wxPyBeginAllowThreads();
5369         result = (int)((wxFrame const *)arg1)->GetStatusBarPane();
5370
5371         wxPyEndAllowThreads(__tstate);
5372         if (PyErr_Occurred()) SWIG_fail;
5373     }
5374     {
5375         resultobj = SWIG_From_int((int)(result));
5376     }
5377     return resultobj;
5378     fail:
5379     return NULL;
5380 }
5381
5382
5383 static PyObject *_wrap_Frame_CreateToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5384     PyObject *resultobj;
5385     wxFrame *arg1 = (wxFrame *) 0 ;
5386     long arg2 = (long) -1 ;
5387     int arg3 = (int) -1 ;
5388     wxString const &arg4_defvalue = wxPyToolBarNameStr ;
5389     wxString *arg4 = (wxString *) &arg4_defvalue ;
5390     wxToolBar *result;
5391     bool temp4 = false ;
5392     PyObject * obj0 = 0 ;
5393     PyObject * obj1 = 0 ;
5394     PyObject * obj2 = 0 ;
5395     PyObject * obj3 = 0 ;
5396     char *kwnames[] = {
5397         (char *) "self",(char *) "style",(char *) "winid",(char *) "name", NULL
5398     };
5399
5400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Frame_CreateToolBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5402     if (SWIG_arg_fail(1)) SWIG_fail;
5403     if (obj1) {
5404         {
5405             arg2 = (long)(SWIG_As_long(obj1));
5406             if (SWIG_arg_fail(2)) SWIG_fail;
5407         }
5408     }
5409     if (obj2) {
5410         {
5411             arg3 = (int)(SWIG_As_int(obj2));
5412             if (SWIG_arg_fail(3)) SWIG_fail;
5413         }
5414     }
5415     if (obj3) {
5416         {
5417             arg4 = wxString_in_helper(obj3);
5418             if (arg4 == NULL) SWIG_fail;
5419             temp4 = true;
5420         }
5421     }
5422     {
5423         PyThreadState* __tstate = wxPyBeginAllowThreads();
5424         result = (wxToolBar *)(arg1)->CreateToolBar(arg2,arg3,(wxString const &)*arg4);
5425
5426         wxPyEndAllowThreads(__tstate);
5427         if (PyErr_Occurred()) SWIG_fail;
5428     }
5429     {
5430         resultobj = wxPyMake_wxObject(result, 0);
5431     }
5432     {
5433         if (temp4)
5434         delete arg4;
5435     }
5436     return resultobj;
5437     fail:
5438     {
5439         if (temp4)
5440         delete arg4;
5441     }
5442     return NULL;
5443 }
5444
5445
5446 static PyObject *_wrap_Frame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5447     PyObject *resultobj;
5448     wxFrame *arg1 = (wxFrame *) 0 ;
5449     wxToolBar *result;
5450     PyObject * obj0 = 0 ;
5451     char *kwnames[] = {
5452         (char *) "self", NULL
5453     };
5454
5455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetToolBar",kwnames,&obj0)) goto fail;
5456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5457     if (SWIG_arg_fail(1)) SWIG_fail;
5458     {
5459         PyThreadState* __tstate = wxPyBeginAllowThreads();
5460         result = (wxToolBar *)((wxFrame const *)arg1)->GetToolBar();
5461
5462         wxPyEndAllowThreads(__tstate);
5463         if (PyErr_Occurred()) SWIG_fail;
5464     }
5465     {
5466         resultobj = wxPyMake_wxObject(result, 0);
5467     }
5468     return resultobj;
5469     fail:
5470     return NULL;
5471 }
5472
5473
5474 static PyObject *_wrap_Frame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5475     PyObject *resultobj;
5476     wxFrame *arg1 = (wxFrame *) 0 ;
5477     wxToolBar *arg2 = (wxToolBar *) 0 ;
5478     PyObject * obj0 = 0 ;
5479     PyObject * obj1 = 0 ;
5480     char *kwnames[] = {
5481         (char *) "self",(char *) "toolbar", NULL
5482     };
5483
5484     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
5485     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5486     if (SWIG_arg_fail(1)) SWIG_fail;
5487     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
5488     if (SWIG_arg_fail(2)) SWIG_fail;
5489     {
5490         PyThreadState* __tstate = wxPyBeginAllowThreads();
5491         (arg1)->SetToolBar(arg2);
5492
5493         wxPyEndAllowThreads(__tstate);
5494         if (PyErr_Occurred()) SWIG_fail;
5495     }
5496     Py_INCREF(Py_None); resultobj = Py_None;
5497     return resultobj;
5498     fail:
5499     return NULL;
5500 }
5501
5502
5503 static PyObject *_wrap_Frame_DoGiveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
5504     PyObject *resultobj;
5505     wxFrame *arg1 = (wxFrame *) 0 ;
5506     wxString *arg2 = 0 ;
5507     bool arg3 ;
5508     bool temp2 = false ;
5509     PyObject * obj0 = 0 ;
5510     PyObject * obj1 = 0 ;
5511     PyObject * obj2 = 0 ;
5512     char *kwnames[] = {
5513         (char *) "self",(char *) "text",(char *) "show", NULL
5514     };
5515
5516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Frame_DoGiveHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
5517     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5518     if (SWIG_arg_fail(1)) SWIG_fail;
5519     {
5520         arg2 = wxString_in_helper(obj1);
5521         if (arg2 == NULL) SWIG_fail;
5522         temp2 = true;
5523     }
5524     {
5525         arg3 = (bool)(SWIG_As_bool(obj2));
5526         if (SWIG_arg_fail(3)) SWIG_fail;
5527     }
5528     {
5529         PyThreadState* __tstate = wxPyBeginAllowThreads();
5530         (arg1)->DoGiveHelp((wxString const &)*arg2,arg3);
5531
5532         wxPyEndAllowThreads(__tstate);
5533         if (PyErr_Occurred()) SWIG_fail;
5534     }
5535     Py_INCREF(Py_None); resultobj = Py_None;
5536     {
5537         if (temp2)
5538         delete arg2;
5539     }
5540     return resultobj;
5541     fail:
5542     {
5543         if (temp2)
5544         delete arg2;
5545     }
5546     return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_Frame_DoMenuUpdates(PyObject *, PyObject *args, PyObject *kwargs) {
5551     PyObject *resultobj;
5552     wxFrame *arg1 = (wxFrame *) 0 ;
5553     wxMenu *arg2 = (wxMenu *) NULL ;
5554     PyObject * obj0 = 0 ;
5555     PyObject * obj1 = 0 ;
5556     char *kwnames[] = {
5557         (char *) "self",(char *) "menu", NULL
5558     };
5559
5560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_DoMenuUpdates",kwnames,&obj0,&obj1)) goto fail;
5561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5562     if (SWIG_arg_fail(1)) SWIG_fail;
5563     if (obj1) {
5564         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
5565         if (SWIG_arg_fail(2)) SWIG_fail;
5566     }
5567     {
5568         PyThreadState* __tstate = wxPyBeginAllowThreads();
5569         (arg1)->DoMenuUpdates(arg2);
5570
5571         wxPyEndAllowThreads(__tstate);
5572         if (PyErr_Occurred()) SWIG_fail;
5573     }
5574     Py_INCREF(Py_None); resultobj = Py_None;
5575     return resultobj;
5576     fail:
5577     return NULL;
5578 }
5579
5580
5581 static PyObject *_wrap_Frame_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5582     PyObject *resultobj;
5583     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5584     wxVisualAttributes result;
5585     PyObject * obj0 = 0 ;
5586     char *kwnames[] = {
5587         (char *) "variant", NULL
5588     };
5589
5590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Frame_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5591     if (obj0) {
5592         {
5593             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5594             if (SWIG_arg_fail(1)) SWIG_fail;
5595         }
5596     }
5597     {
5598         if (!wxPyCheckForApp()) SWIG_fail;
5599         PyThreadState* __tstate = wxPyBeginAllowThreads();
5600         result = wxFrame::GetClassDefaultAttributes((wxWindowVariant )arg1);
5601
5602         wxPyEndAllowThreads(__tstate);
5603         if (PyErr_Occurred()) SWIG_fail;
5604     }
5605     {
5606         wxVisualAttributes * resultptr;
5607         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5608         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5609     }
5610     return resultobj;
5611     fail:
5612     return NULL;
5613 }
5614
5615
5616 static PyObject * Frame_swigregister(PyObject *, PyObject *args) {
5617     PyObject *obj;
5618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5619     SWIG_TypeClientData(SWIGTYPE_p_wxFrame, obj);
5620     Py_INCREF(obj);
5621     return Py_BuildValue((char *)"");
5622 }
5623 static PyObject *_wrap_new_Dialog(PyObject *, PyObject *args, PyObject *kwargs) {
5624     PyObject *resultobj;
5625     wxWindow *arg1 = (wxWindow *) 0 ;
5626     int arg2 = (int) (int)-1 ;
5627     wxString const &arg3_defvalue = wxPyEmptyString ;
5628     wxString *arg3 = (wxString *) &arg3_defvalue ;
5629     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5630     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5631     wxSize const &arg5_defvalue = wxDefaultSize ;
5632     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5633     long arg6 = (long) wxDEFAULT_DIALOG_STYLE ;
5634     wxString const &arg7_defvalue = wxPyDialogNameStr ;
5635     wxString *arg7 = (wxString *) &arg7_defvalue ;
5636     wxDialog *result;
5637     bool temp3 = false ;
5638     wxPoint temp4 ;
5639     wxSize temp5 ;
5640     bool temp7 = false ;
5641     PyObject * obj0 = 0 ;
5642     PyObject * obj1 = 0 ;
5643     PyObject * obj2 = 0 ;
5644     PyObject * obj3 = 0 ;
5645     PyObject * obj4 = 0 ;
5646     PyObject * obj5 = 0 ;
5647     PyObject * obj6 = 0 ;
5648     char *kwnames[] = {
5649         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5650     };
5651
5652     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Dialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5653     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5654     if (SWIG_arg_fail(1)) SWIG_fail;
5655     if (obj1) {
5656         {
5657             arg2 = (int const)(SWIG_As_int(obj1));
5658             if (SWIG_arg_fail(2)) SWIG_fail;
5659         }
5660     }
5661     if (obj2) {
5662         {
5663             arg3 = wxString_in_helper(obj2);
5664             if (arg3 == NULL) SWIG_fail;
5665             temp3 = true;
5666         }
5667     }
5668     if (obj3) {
5669         {
5670             arg4 = &temp4;
5671             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5672         }
5673     }
5674     if (obj4) {
5675         {
5676             arg5 = &temp5;
5677             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5678         }
5679     }
5680     if (obj5) {
5681         {
5682             arg6 = (long)(SWIG_As_long(obj5));
5683             if (SWIG_arg_fail(6)) SWIG_fail;
5684         }
5685     }
5686     if (obj6) {
5687         {
5688             arg7 = wxString_in_helper(obj6);
5689             if (arg7 == NULL) SWIG_fail;
5690             temp7 = true;
5691         }
5692     }
5693     {
5694         if (!wxPyCheckForApp()) SWIG_fail;
5695         PyThreadState* __tstate = wxPyBeginAllowThreads();
5696         result = (wxDialog *)new wxDialog(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
5697
5698         wxPyEndAllowThreads(__tstate);
5699         if (PyErr_Occurred()) SWIG_fail;
5700     }
5701     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5702     {
5703         if (temp3)
5704         delete arg3;
5705     }
5706     {
5707         if (temp7)
5708         delete arg7;
5709     }
5710     return resultobj;
5711     fail:
5712     {
5713         if (temp3)
5714         delete arg3;
5715     }
5716     {
5717         if (temp7)
5718         delete arg7;
5719     }
5720     return NULL;
5721 }
5722
5723
5724 static PyObject *_wrap_new_PreDialog(PyObject *, PyObject *args, PyObject *kwargs) {
5725     PyObject *resultobj;
5726     wxDialog *result;
5727     char *kwnames[] = {
5728         NULL
5729     };
5730
5731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDialog",kwnames)) goto fail;
5732     {
5733         if (!wxPyCheckForApp()) SWIG_fail;
5734         PyThreadState* __tstate = wxPyBeginAllowThreads();
5735         result = (wxDialog *)new wxDialog();
5736
5737         wxPyEndAllowThreads(__tstate);
5738         if (PyErr_Occurred()) SWIG_fail;
5739     }
5740     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5741     return resultobj;
5742     fail:
5743     return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_Dialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5748     PyObject *resultobj;
5749     wxDialog *arg1 = (wxDialog *) 0 ;
5750     wxWindow *arg2 = (wxWindow *) 0 ;
5751     int arg3 = (int) (int)-1 ;
5752     wxString const &arg4_defvalue = wxPyEmptyString ;
5753     wxString *arg4 = (wxString *) &arg4_defvalue ;
5754     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5755     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5756     wxSize const &arg6_defvalue = wxDefaultSize ;
5757     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5758     long arg7 = (long) wxDEFAULT_DIALOG_STYLE ;
5759     wxString const &arg8_defvalue = wxPyDialogNameStr ;
5760     wxString *arg8 = (wxString *) &arg8_defvalue ;
5761     bool result;
5762     bool temp4 = false ;
5763     wxPoint temp5 ;
5764     wxSize temp6 ;
5765     bool temp8 = false ;
5766     PyObject * obj0 = 0 ;
5767     PyObject * obj1 = 0 ;
5768     PyObject * obj2 = 0 ;
5769     PyObject * obj3 = 0 ;
5770     PyObject * obj4 = 0 ;
5771     PyObject * obj5 = 0 ;
5772     PyObject * obj6 = 0 ;
5773     PyObject * obj7 = 0 ;
5774     char *kwnames[] = {
5775         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5776     };
5777
5778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Dialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5780     if (SWIG_arg_fail(1)) SWIG_fail;
5781     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5782     if (SWIG_arg_fail(2)) SWIG_fail;
5783     if (obj2) {
5784         {
5785             arg3 = (int const)(SWIG_As_int(obj2));
5786             if (SWIG_arg_fail(3)) SWIG_fail;
5787         }
5788     }
5789     if (obj3) {
5790         {
5791             arg4 = wxString_in_helper(obj3);
5792             if (arg4 == NULL) SWIG_fail;
5793             temp4 = true;
5794         }
5795     }
5796     if (obj4) {
5797         {
5798             arg5 = &temp5;
5799             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5800         }
5801     }
5802     if (obj5) {
5803         {
5804             arg6 = &temp6;
5805             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5806         }
5807     }
5808     if (obj6) {
5809         {
5810             arg7 = (long)(SWIG_As_long(obj6));
5811             if (SWIG_arg_fail(7)) SWIG_fail;
5812         }
5813     }
5814     if (obj7) {
5815         {
5816             arg8 = wxString_in_helper(obj7);
5817             if (arg8 == NULL) SWIG_fail;
5818             temp8 = true;
5819         }
5820     }
5821     {
5822         PyThreadState* __tstate = wxPyBeginAllowThreads();
5823         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
5824
5825         wxPyEndAllowThreads(__tstate);
5826         if (PyErr_Occurred()) SWIG_fail;
5827     }
5828     {
5829         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5830     }
5831     {
5832         if (temp4)
5833         delete arg4;
5834     }
5835     {
5836         if (temp8)
5837         delete arg8;
5838     }
5839     return resultobj;
5840     fail:
5841     {
5842         if (temp4)
5843         delete arg4;
5844     }
5845     {
5846         if (temp8)
5847         delete arg8;
5848     }
5849     return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Dialog_SetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5854     PyObject *resultobj;
5855     wxDialog *arg1 = (wxDialog *) 0 ;
5856     int arg2 ;
5857     PyObject * obj0 = 0 ;
5858     PyObject * obj1 = 0 ;
5859     char *kwnames[] = {
5860         (char *) "self",(char *) "returnCode", NULL
5861     };
5862
5863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_SetReturnCode",kwnames,&obj0,&obj1)) goto fail;
5864     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5865     if (SWIG_arg_fail(1)) SWIG_fail;
5866     {
5867         arg2 = (int)(SWIG_As_int(obj1));
5868         if (SWIG_arg_fail(2)) SWIG_fail;
5869     }
5870     {
5871         PyThreadState* __tstate = wxPyBeginAllowThreads();
5872         (arg1)->SetReturnCode(arg2);
5873
5874         wxPyEndAllowThreads(__tstate);
5875         if (PyErr_Occurred()) SWIG_fail;
5876     }
5877     Py_INCREF(Py_None); resultobj = Py_None;
5878     return resultobj;
5879     fail:
5880     return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_Dialog_GetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5885     PyObject *resultobj;
5886     wxDialog *arg1 = (wxDialog *) 0 ;
5887     int result;
5888     PyObject * obj0 = 0 ;
5889     char *kwnames[] = {
5890         (char *) "self", NULL
5891     };
5892
5893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_GetReturnCode",kwnames,&obj0)) goto fail;
5894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5895     if (SWIG_arg_fail(1)) SWIG_fail;
5896     {
5897         PyThreadState* __tstate = wxPyBeginAllowThreads();
5898         result = (int)((wxDialog const *)arg1)->GetReturnCode();
5899
5900         wxPyEndAllowThreads(__tstate);
5901         if (PyErr_Occurred()) SWIG_fail;
5902     }
5903     {
5904         resultobj = SWIG_From_int((int)(result));
5905     }
5906     return resultobj;
5907     fail:
5908     return NULL;
5909 }
5910
5911
5912 static PyObject *_wrap_Dialog_CreateTextSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5913     PyObject *resultobj;
5914     wxDialog *arg1 = (wxDialog *) 0 ;
5915     wxString *arg2 = 0 ;
5916     wxSizer *result;
5917     bool temp2 = false ;
5918     PyObject * obj0 = 0 ;
5919     PyObject * obj1 = 0 ;
5920     char *kwnames[] = {
5921         (char *) "self",(char *) "message", NULL
5922     };
5923
5924     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateTextSizer",kwnames,&obj0,&obj1)) goto fail;
5925     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5926     if (SWIG_arg_fail(1)) SWIG_fail;
5927     {
5928         arg2 = wxString_in_helper(obj1);
5929         if (arg2 == NULL) SWIG_fail;
5930         temp2 = true;
5931     }
5932     {
5933         PyThreadState* __tstate = wxPyBeginAllowThreads();
5934         result = (wxSizer *)(arg1)->CreateTextSizer((wxString const &)*arg2);
5935
5936         wxPyEndAllowThreads(__tstate);
5937         if (PyErr_Occurred()) SWIG_fail;
5938     }
5939     {
5940         resultobj = wxPyMake_wxSizer(result, 0);
5941     }
5942     {
5943         if (temp2)
5944         delete arg2;
5945     }
5946     return resultobj;
5947     fail:
5948     {
5949         if (temp2)
5950         delete arg2;
5951     }
5952     return NULL;
5953 }
5954
5955
5956 static PyObject *_wrap_Dialog_CreateButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5957     PyObject *resultobj;
5958     wxDialog *arg1 = (wxDialog *) 0 ;
5959     long arg2 ;
5960     wxSizer *result;
5961     PyObject * obj0 = 0 ;
5962     PyObject * obj1 = 0 ;
5963     char *kwnames[] = {
5964         (char *) "self",(char *) "flags", NULL
5965     };
5966
5967     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateButtonSizer",kwnames,&obj0,&obj1)) goto fail;
5968     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5969     if (SWIG_arg_fail(1)) SWIG_fail;
5970     {
5971         arg2 = (long)(SWIG_As_long(obj1));
5972         if (SWIG_arg_fail(2)) SWIG_fail;
5973     }
5974     {
5975         PyThreadState* __tstate = wxPyBeginAllowThreads();
5976         result = (wxSizer *)(arg1)->CreateButtonSizer(arg2);
5977
5978         wxPyEndAllowThreads(__tstate);
5979         if (PyErr_Occurred()) SWIG_fail;
5980     }
5981     {
5982         resultobj = wxPyMake_wxSizer(result, 0);
5983     }
5984     return resultobj;
5985     fail:
5986     return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_Dialog_CreateStdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5991     PyObject *resultobj;
5992     wxDialog *arg1 = (wxDialog *) 0 ;
5993     long arg2 ;
5994     wxStdDialogButtonSizer *result;
5995     PyObject * obj0 = 0 ;
5996     PyObject * obj1 = 0 ;
5997     char *kwnames[] = {
5998         (char *) "self",(char *) "flags", NULL
5999     };
6000
6001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateStdDialogButtonSizer",kwnames,&obj0,&obj1)) goto fail;
6002     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6003     if (SWIG_arg_fail(1)) SWIG_fail;
6004     {
6005         arg2 = (long)(SWIG_As_long(obj1));
6006         if (SWIG_arg_fail(2)) SWIG_fail;
6007     }
6008     {
6009         PyThreadState* __tstate = wxPyBeginAllowThreads();
6010         result = (wxStdDialogButtonSizer *)(arg1)->CreateStdDialogButtonSizer(arg2);
6011
6012         wxPyEndAllowThreads(__tstate);
6013         if (PyErr_Occurred()) SWIG_fail;
6014     }
6015     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 0);
6016     return resultobj;
6017     fail:
6018     return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_Dialog_IsModal(PyObject *, PyObject *args, PyObject *kwargs) {
6023     PyObject *resultobj;
6024     wxDialog *arg1 = (wxDialog *) 0 ;
6025     bool result;
6026     PyObject * obj0 = 0 ;
6027     char *kwnames[] = {
6028         (char *) "self", NULL
6029     };
6030
6031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_IsModal",kwnames,&obj0)) goto fail;
6032     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6033     if (SWIG_arg_fail(1)) SWIG_fail;
6034     {
6035         PyThreadState* __tstate = wxPyBeginAllowThreads();
6036         result = (bool)((wxDialog const *)arg1)->IsModal();
6037
6038         wxPyEndAllowThreads(__tstate);
6039         if (PyErr_Occurred()) SWIG_fail;
6040     }
6041     {
6042         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6043     }
6044     return resultobj;
6045     fail:
6046     return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_Dialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
6051     PyObject *resultobj;
6052     wxDialog *arg1 = (wxDialog *) 0 ;
6053     int result;
6054     PyObject * obj0 = 0 ;
6055     char *kwnames[] = {
6056         (char *) "self", NULL
6057     };
6058
6059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_ShowModal",kwnames,&obj0)) goto fail;
6060     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6061     if (SWIG_arg_fail(1)) SWIG_fail;
6062     {
6063         PyThreadState* __tstate = wxPyBeginAllowThreads();
6064         result = (int)(arg1)->ShowModal();
6065
6066         wxPyEndAllowThreads(__tstate);
6067         if (PyErr_Occurred()) SWIG_fail;
6068     }
6069     {
6070         resultobj = SWIG_From_int((int)(result));
6071     }
6072     return resultobj;
6073     fail:
6074     return NULL;
6075 }
6076
6077
6078 static PyObject *_wrap_Dialog_EndModal(PyObject *, PyObject *args, PyObject *kwargs) {
6079     PyObject *resultobj;
6080     wxDialog *arg1 = (wxDialog *) 0 ;
6081     int arg2 ;
6082     PyObject * obj0 = 0 ;
6083     PyObject * obj1 = 0 ;
6084     char *kwnames[] = {
6085         (char *) "self",(char *) "retCode", NULL
6086     };
6087
6088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_EndModal",kwnames,&obj0,&obj1)) goto fail;
6089     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6090     if (SWIG_arg_fail(1)) SWIG_fail;
6091     {
6092         arg2 = (int)(SWIG_As_int(obj1));
6093         if (SWIG_arg_fail(2)) SWIG_fail;
6094     }
6095     {
6096         PyThreadState* __tstate = wxPyBeginAllowThreads();
6097         (arg1)->EndModal(arg2);
6098
6099         wxPyEndAllowThreads(__tstate);
6100         if (PyErr_Occurred()) SWIG_fail;
6101     }
6102     Py_INCREF(Py_None); resultobj = Py_None;
6103     return resultobj;
6104     fail:
6105     return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_Dialog_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6110     PyObject *resultobj;
6111     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6112     wxVisualAttributes result;
6113     PyObject * obj0 = 0 ;
6114     char *kwnames[] = {
6115         (char *) "variant", NULL
6116     };
6117
6118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Dialog_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6119     if (obj0) {
6120         {
6121             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6122             if (SWIG_arg_fail(1)) SWIG_fail;
6123         }
6124     }
6125     {
6126         if (!wxPyCheckForApp()) SWIG_fail;
6127         PyThreadState* __tstate = wxPyBeginAllowThreads();
6128         result = wxDialog::GetClassDefaultAttributes((wxWindowVariant )arg1);
6129
6130         wxPyEndAllowThreads(__tstate);
6131         if (PyErr_Occurred()) SWIG_fail;
6132     }
6133     {
6134         wxVisualAttributes * resultptr;
6135         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6136         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6137     }
6138     return resultobj;
6139     fail:
6140     return NULL;
6141 }
6142
6143
6144 static PyObject * Dialog_swigregister(PyObject *, PyObject *args) {
6145     PyObject *obj;
6146     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6147     SWIG_TypeClientData(SWIGTYPE_p_wxDialog, obj);
6148     Py_INCREF(obj);
6149     return Py_BuildValue((char *)"");
6150 }
6151 static PyObject *_wrap_new_MiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6152     PyObject *resultobj;
6153     wxWindow *arg1 = (wxWindow *) 0 ;
6154     int arg2 = (int) (int)-1 ;
6155     wxString const &arg3_defvalue = wxPyEmptyString ;
6156     wxString *arg3 = (wxString *) &arg3_defvalue ;
6157     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6158     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6159     wxSize const &arg5_defvalue = wxDefaultSize ;
6160     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6161     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
6162     wxString const &arg7_defvalue = wxPyFrameNameStr ;
6163     wxString *arg7 = (wxString *) &arg7_defvalue ;
6164     wxMiniFrame *result;
6165     bool temp3 = false ;
6166     wxPoint temp4 ;
6167     wxSize temp5 ;
6168     bool temp7 = false ;
6169     PyObject * obj0 = 0 ;
6170     PyObject * obj1 = 0 ;
6171     PyObject * obj2 = 0 ;
6172     PyObject * obj3 = 0 ;
6173     PyObject * obj4 = 0 ;
6174     PyObject * obj5 = 0 ;
6175     PyObject * obj6 = 0 ;
6176     char *kwnames[] = {
6177         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6178     };
6179
6180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MiniFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6182     if (SWIG_arg_fail(1)) SWIG_fail;
6183     if (obj1) {
6184         {
6185             arg2 = (int const)(SWIG_As_int(obj1));
6186             if (SWIG_arg_fail(2)) SWIG_fail;
6187         }
6188     }
6189     if (obj2) {
6190         {
6191             arg3 = wxString_in_helper(obj2);
6192             if (arg3 == NULL) SWIG_fail;
6193             temp3 = true;
6194         }
6195     }
6196     if (obj3) {
6197         {
6198             arg4 = &temp4;
6199             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6200         }
6201     }
6202     if (obj4) {
6203         {
6204             arg5 = &temp5;
6205             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6206         }
6207     }
6208     if (obj5) {
6209         {
6210             arg6 = (long)(SWIG_As_long(obj5));
6211             if (SWIG_arg_fail(6)) SWIG_fail;
6212         }
6213     }
6214     if (obj6) {
6215         {
6216             arg7 = wxString_in_helper(obj6);
6217             if (arg7 == NULL) SWIG_fail;
6218             temp7 = true;
6219         }
6220     }
6221     {
6222         if (!wxPyCheckForApp()) SWIG_fail;
6223         PyThreadState* __tstate = wxPyBeginAllowThreads();
6224         result = (wxMiniFrame *)new wxMiniFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6225
6226         wxPyEndAllowThreads(__tstate);
6227         if (PyErr_Occurred()) SWIG_fail;
6228     }
6229     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6230     {
6231         if (temp3)
6232         delete arg3;
6233     }
6234     {
6235         if (temp7)
6236         delete arg7;
6237     }
6238     return resultobj;
6239     fail:
6240     {
6241         if (temp3)
6242         delete arg3;
6243     }
6244     {
6245         if (temp7)
6246         delete arg7;
6247     }
6248     return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_new_PreMiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6253     PyObject *resultobj;
6254     wxMiniFrame *result;
6255     char *kwnames[] = {
6256         NULL
6257     };
6258
6259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMiniFrame",kwnames)) goto fail;
6260     {
6261         if (!wxPyCheckForApp()) SWIG_fail;
6262         PyThreadState* __tstate = wxPyBeginAllowThreads();
6263         result = (wxMiniFrame *)new wxMiniFrame();
6264
6265         wxPyEndAllowThreads(__tstate);
6266         if (PyErr_Occurred()) SWIG_fail;
6267     }
6268     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6269     return resultobj;
6270     fail:
6271     return NULL;
6272 }
6273
6274
6275 static PyObject *_wrap_MiniFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6276     PyObject *resultobj;
6277     wxMiniFrame *arg1 = (wxMiniFrame *) 0 ;
6278     wxWindow *arg2 = (wxWindow *) 0 ;
6279     int arg3 = (int) (int)-1 ;
6280     wxString const &arg4_defvalue = wxPyEmptyString ;
6281     wxString *arg4 = (wxString *) &arg4_defvalue ;
6282     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6283     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6284     wxSize const &arg6_defvalue = wxDefaultSize ;
6285     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6286     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
6287     wxString const &arg8_defvalue = wxPyFrameNameStr ;
6288     wxString *arg8 = (wxString *) &arg8_defvalue ;
6289     bool result;
6290     bool temp4 = false ;
6291     wxPoint temp5 ;
6292     wxSize temp6 ;
6293     bool temp8 = false ;
6294     PyObject * obj0 = 0 ;
6295     PyObject * obj1 = 0 ;
6296     PyObject * obj2 = 0 ;
6297     PyObject * obj3 = 0 ;
6298     PyObject * obj4 = 0 ;
6299     PyObject * obj5 = 0 ;
6300     PyObject * obj6 = 0 ;
6301     PyObject * obj7 = 0 ;
6302     char *kwnames[] = {
6303         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6304     };
6305
6306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MiniFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMiniFrame, SWIG_POINTER_EXCEPTION | 0);
6308     if (SWIG_arg_fail(1)) SWIG_fail;
6309     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6310     if (SWIG_arg_fail(2)) SWIG_fail;
6311     if (obj2) {
6312         {
6313             arg3 = (int const)(SWIG_As_int(obj2));
6314             if (SWIG_arg_fail(3)) SWIG_fail;
6315         }
6316     }
6317     if (obj3) {
6318         {
6319             arg4 = wxString_in_helper(obj3);
6320             if (arg4 == NULL) SWIG_fail;
6321             temp4 = true;
6322         }
6323     }
6324     if (obj4) {
6325         {
6326             arg5 = &temp5;
6327             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6328         }
6329     }
6330     if (obj5) {
6331         {
6332             arg6 = &temp6;
6333             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6334         }
6335     }
6336     if (obj6) {
6337         {
6338             arg7 = (long)(SWIG_As_long(obj6));
6339             if (SWIG_arg_fail(7)) SWIG_fail;
6340         }
6341     }
6342     if (obj7) {
6343         {
6344             arg8 = wxString_in_helper(obj7);
6345             if (arg8 == NULL) SWIG_fail;
6346             temp8 = true;
6347         }
6348     }
6349     {
6350         PyThreadState* __tstate = wxPyBeginAllowThreads();
6351         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6352
6353         wxPyEndAllowThreads(__tstate);
6354         if (PyErr_Occurred()) SWIG_fail;
6355     }
6356     {
6357         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6358     }
6359     {
6360         if (temp4)
6361         delete arg4;
6362     }
6363     {
6364         if (temp8)
6365         delete arg8;
6366     }
6367     return resultobj;
6368     fail:
6369     {
6370         if (temp4)
6371         delete arg4;
6372     }
6373     {
6374         if (temp8)
6375         delete arg8;
6376     }
6377     return NULL;
6378 }
6379
6380
6381 static PyObject * MiniFrame_swigregister(PyObject *, PyObject *args) {
6382     PyObject *obj;
6383     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6384     SWIG_TypeClientData(SWIGTYPE_p_wxMiniFrame, obj);
6385     Py_INCREF(obj);
6386     return Py_BuildValue((char *)"");
6387 }
6388 static PyObject *_wrap_new_SplashScreenWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6389     PyObject *resultobj;
6390     wxBitmap *arg1 = 0 ;
6391     wxWindow *arg2 = (wxWindow *) 0 ;
6392     int arg3 ;
6393     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6394     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6395     wxSize const &arg5_defvalue = wxDefaultSize ;
6396     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6397     long arg6 = (long) wxNO_BORDER ;
6398     wxSplashScreenWindow *result;
6399     wxPoint temp4 ;
6400     wxSize temp5 ;
6401     PyObject * obj0 = 0 ;
6402     PyObject * obj1 = 0 ;
6403     PyObject * obj2 = 0 ;
6404     PyObject * obj3 = 0 ;
6405     PyObject * obj4 = 0 ;
6406     PyObject * obj5 = 0 ;
6407     char *kwnames[] = {
6408         (char *) "bitmap",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6409     };
6410
6411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_SplashScreenWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6412     {
6413         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6414         if (SWIG_arg_fail(1)) SWIG_fail;
6415         if (arg1 == NULL) {
6416             SWIG_null_ref("wxBitmap");
6417         }
6418         if (SWIG_arg_fail(1)) SWIG_fail;
6419     }
6420     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6421     if (SWIG_arg_fail(2)) SWIG_fail;
6422     {
6423         arg3 = (int)(SWIG_As_int(obj2));
6424         if (SWIG_arg_fail(3)) SWIG_fail;
6425     }
6426     if (obj3) {
6427         {
6428             arg4 = &temp4;
6429             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6430         }
6431     }
6432     if (obj4) {
6433         {
6434             arg5 = &temp5;
6435             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6436         }
6437     }
6438     if (obj5) {
6439         {
6440             arg6 = (long)(SWIG_As_long(obj5));
6441             if (SWIG_arg_fail(6)) SWIG_fail;
6442         }
6443     }
6444     {
6445         if (!wxPyCheckForApp()) SWIG_fail;
6446         PyThreadState* __tstate = wxPyBeginAllowThreads();
6447         result = (wxSplashScreenWindow *)new wxSplashScreenWindow((wxBitmap const &)*arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
6448
6449         wxPyEndAllowThreads(__tstate);
6450         if (PyErr_Occurred()) SWIG_fail;
6451     }
6452     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 1);
6453     return resultobj;
6454     fail:
6455     return NULL;
6456 }
6457
6458
6459 static PyObject *_wrap_SplashScreenWindow_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6460     PyObject *resultobj;
6461     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6462     wxBitmap *arg2 = 0 ;
6463     PyObject * obj0 = 0 ;
6464     PyObject * obj1 = 0 ;
6465     char *kwnames[] = {
6466         (char *) "self",(char *) "bitmap", NULL
6467     };
6468
6469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplashScreenWindow_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
6470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6471     if (SWIG_arg_fail(1)) SWIG_fail;
6472     {
6473         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6474         if (SWIG_arg_fail(2)) SWIG_fail;
6475         if (arg2 == NULL) {
6476             SWIG_null_ref("wxBitmap");
6477         }
6478         if (SWIG_arg_fail(2)) SWIG_fail;
6479     }
6480     {
6481         PyThreadState* __tstate = wxPyBeginAllowThreads();
6482         (arg1)->SetBitmap((wxBitmap const &)*arg2);
6483
6484         wxPyEndAllowThreads(__tstate);
6485         if (PyErr_Occurred()) SWIG_fail;
6486     }
6487     Py_INCREF(Py_None); resultobj = Py_None;
6488     return resultobj;
6489     fail:
6490     return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_SplashScreenWindow_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6495     PyObject *resultobj;
6496     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6497     wxBitmap *result;
6498     PyObject * obj0 = 0 ;
6499     char *kwnames[] = {
6500         (char *) "self", NULL
6501     };
6502
6503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreenWindow_GetBitmap",kwnames,&obj0)) goto fail;
6504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6505     if (SWIG_arg_fail(1)) SWIG_fail;
6506     {
6507         PyThreadState* __tstate = wxPyBeginAllowThreads();
6508         {
6509             wxBitmap &_result_ref = (arg1)->GetBitmap();
6510             result = (wxBitmap *) &_result_ref;
6511         }
6512
6513         wxPyEndAllowThreads(__tstate);
6514         if (PyErr_Occurred()) SWIG_fail;
6515     }
6516     {
6517         wxBitmap* resultptr = new wxBitmap(*result);
6518         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
6519     }
6520     return resultobj;
6521     fail:
6522     return NULL;
6523 }
6524
6525
6526 static PyObject * SplashScreenWindow_swigregister(PyObject *, PyObject *args) {
6527     PyObject *obj;
6528     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6529     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreenWindow, obj);
6530     Py_INCREF(obj);
6531     return Py_BuildValue((char *)"");
6532 }
6533 static PyObject *_wrap_new_SplashScreen(PyObject *, PyObject *args, PyObject *kwargs) {
6534     PyObject *resultobj;
6535     wxBitmap *arg1 = 0 ;
6536     long arg2 ;
6537     int arg3 ;
6538     wxWindow *arg4 = (wxWindow *) 0 ;
6539     int arg5 = (int) -1 ;
6540     wxPoint const &arg6_defvalue = wxDefaultPosition ;
6541     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
6542     wxSize const &arg7_defvalue = wxDefaultSize ;
6543     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
6544     long arg8 = (long) wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP ;
6545     wxSplashScreen *result;
6546     wxPoint temp6 ;
6547     wxSize temp7 ;
6548     PyObject * obj0 = 0 ;
6549     PyObject * obj1 = 0 ;
6550     PyObject * obj2 = 0 ;
6551     PyObject * obj3 = 0 ;
6552     PyObject * obj4 = 0 ;
6553     PyObject * obj5 = 0 ;
6554     PyObject * obj6 = 0 ;
6555     PyObject * obj7 = 0 ;
6556     char *kwnames[] = {
6557         (char *) "bitmap",(char *) "splashStyle",(char *) "milliseconds",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6558     };
6559
6560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:new_SplashScreen",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6561     {
6562         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6563         if (SWIG_arg_fail(1)) SWIG_fail;
6564         if (arg1 == NULL) {
6565             SWIG_null_ref("wxBitmap");
6566         }
6567         if (SWIG_arg_fail(1)) SWIG_fail;
6568     }
6569     {
6570         arg2 = (long)(SWIG_As_long(obj1));
6571         if (SWIG_arg_fail(2)) SWIG_fail;
6572     }
6573     {
6574         arg3 = (int)(SWIG_As_int(obj2));
6575         if (SWIG_arg_fail(3)) SWIG_fail;
6576     }
6577     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6578     if (SWIG_arg_fail(4)) SWIG_fail;
6579     if (obj4) {
6580         {
6581             arg5 = (int)(SWIG_As_int(obj4));
6582             if (SWIG_arg_fail(5)) SWIG_fail;
6583         }
6584     }
6585     if (obj5) {
6586         {
6587             arg6 = &temp6;
6588             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
6589         }
6590     }
6591     if (obj6) {
6592         {
6593             arg7 = &temp7;
6594             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
6595         }
6596     }
6597     if (obj7) {
6598         {
6599             arg8 = (long)(SWIG_As_long(obj7));
6600             if (SWIG_arg_fail(8)) SWIG_fail;
6601         }
6602     }
6603     {
6604         if (!wxPyCheckForApp()) SWIG_fail;
6605         PyThreadState* __tstate = wxPyBeginAllowThreads();
6606         result = (wxSplashScreen *)new wxSplashScreen((wxBitmap const &)*arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8);
6607
6608         wxPyEndAllowThreads(__tstate);
6609         if (PyErr_Occurred()) SWIG_fail;
6610     }
6611     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreen, 1);
6612     return resultobj;
6613     fail:
6614     return NULL;
6615 }
6616
6617
6618 static PyObject *_wrap_SplashScreen_GetSplashStyle(PyObject *, PyObject *args, PyObject *kwargs) {
6619     PyObject *resultobj;
6620     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6621     long result;
6622     PyObject * obj0 = 0 ;
6623     char *kwnames[] = {
6624         (char *) "self", NULL
6625     };
6626
6627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashStyle",kwnames,&obj0)) goto fail;
6628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6629     if (SWIG_arg_fail(1)) SWIG_fail;
6630     {
6631         PyThreadState* __tstate = wxPyBeginAllowThreads();
6632         result = (long)((wxSplashScreen const *)arg1)->GetSplashStyle();
6633
6634         wxPyEndAllowThreads(__tstate);
6635         if (PyErr_Occurred()) SWIG_fail;
6636     }
6637     {
6638         resultobj = SWIG_From_long((long)(result));
6639     }
6640     return resultobj;
6641     fail:
6642     return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_SplashScreen_GetSplashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6647     PyObject *resultobj;
6648     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6649     wxSplashScreenWindow *result;
6650     PyObject * obj0 = 0 ;
6651     char *kwnames[] = {
6652         (char *) "self", NULL
6653     };
6654
6655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashWindow",kwnames,&obj0)) goto fail;
6656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6657     if (SWIG_arg_fail(1)) SWIG_fail;
6658     {
6659         PyThreadState* __tstate = wxPyBeginAllowThreads();
6660         result = (wxSplashScreenWindow *)((wxSplashScreen const *)arg1)->GetSplashWindow();
6661
6662         wxPyEndAllowThreads(__tstate);
6663         if (PyErr_Occurred()) SWIG_fail;
6664     }
6665     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 0);
6666     return resultobj;
6667     fail:
6668     return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_SplashScreen_GetTimeout(PyObject *, PyObject *args, PyObject *kwargs) {
6673     PyObject *resultobj;
6674     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6675     int result;
6676     PyObject * obj0 = 0 ;
6677     char *kwnames[] = {
6678         (char *) "self", NULL
6679     };
6680
6681     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetTimeout",kwnames,&obj0)) goto fail;
6682     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6683     if (SWIG_arg_fail(1)) SWIG_fail;
6684     {
6685         PyThreadState* __tstate = wxPyBeginAllowThreads();
6686         result = (int)((wxSplashScreen const *)arg1)->GetTimeout();
6687
6688         wxPyEndAllowThreads(__tstate);
6689         if (PyErr_Occurred()) SWIG_fail;
6690     }
6691     {
6692         resultobj = SWIG_From_int((int)(result));
6693     }
6694     return resultobj;
6695     fail:
6696     return NULL;
6697 }
6698
6699
6700 static PyObject * SplashScreen_swigregister(PyObject *, PyObject *args) {
6701     PyObject *obj;
6702     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6703     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreen, obj);
6704     Py_INCREF(obj);
6705     return Py_BuildValue((char *)"");
6706 }
6707 static PyObject *_wrap_new_StatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6708     PyObject *resultobj;
6709     wxWindow *arg1 = (wxWindow *) 0 ;
6710     int arg2 = (int) -1 ;
6711     long arg3 = (long) wxDEFAULT_STATUSBAR_STYLE ;
6712     wxString const &arg4_defvalue = wxPyStatusLineNameStr ;
6713     wxString *arg4 = (wxString *) &arg4_defvalue ;
6714     wxStatusBar *result;
6715     bool temp4 = false ;
6716     PyObject * obj0 = 0 ;
6717     PyObject * obj1 = 0 ;
6718     PyObject * obj2 = 0 ;
6719     PyObject * obj3 = 0 ;
6720     char *kwnames[] = {
6721         (char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6722     };
6723
6724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_StatusBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6726     if (SWIG_arg_fail(1)) SWIG_fail;
6727     if (obj1) {
6728         {
6729             arg2 = (int)(SWIG_As_int(obj1));
6730             if (SWIG_arg_fail(2)) SWIG_fail;
6731         }
6732     }
6733     if (obj2) {
6734         {
6735             arg3 = (long)(SWIG_As_long(obj2));
6736             if (SWIG_arg_fail(3)) SWIG_fail;
6737         }
6738     }
6739     if (obj3) {
6740         {
6741             arg4 = wxString_in_helper(obj3);
6742             if (arg4 == NULL) SWIG_fail;
6743             temp4 = true;
6744         }
6745     }
6746     {
6747         if (!wxPyCheckForApp()) SWIG_fail;
6748         PyThreadState* __tstate = wxPyBeginAllowThreads();
6749         result = (wxStatusBar *)new wxStatusBar(arg1,arg2,arg3,(wxString const &)*arg4);
6750
6751         wxPyEndAllowThreads(__tstate);
6752         if (PyErr_Occurred()) SWIG_fail;
6753     }
6754     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6755     {
6756         if (temp4)
6757         delete arg4;
6758     }
6759     return resultobj;
6760     fail:
6761     {
6762         if (temp4)
6763         delete arg4;
6764     }
6765     return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_new_PreStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6770     PyObject *resultobj;
6771     wxStatusBar *result;
6772     char *kwnames[] = {
6773         NULL
6774     };
6775
6776     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStatusBar",kwnames)) goto fail;
6777     {
6778         if (!wxPyCheckForApp()) SWIG_fail;
6779         PyThreadState* __tstate = wxPyBeginAllowThreads();
6780         result = (wxStatusBar *)new wxStatusBar();
6781
6782         wxPyEndAllowThreads(__tstate);
6783         if (PyErr_Occurred()) SWIG_fail;
6784     }
6785     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6786     return resultobj;
6787     fail:
6788     return NULL;
6789 }
6790
6791
6792 static PyObject *_wrap_StatusBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6793     PyObject *resultobj;
6794     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6795     wxWindow *arg2 = (wxWindow *) 0 ;
6796     int arg3 = (int) -1 ;
6797     long arg4 = (long) wxST_SIZEGRIP ;
6798     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
6799     wxString *arg5 = (wxString *) &arg5_defvalue ;
6800     bool result;
6801     bool temp5 = false ;
6802     PyObject * obj0 = 0 ;
6803     PyObject * obj1 = 0 ;
6804     PyObject * obj2 = 0 ;
6805     PyObject * obj3 = 0 ;
6806     PyObject * obj4 = 0 ;
6807     char *kwnames[] = {
6808         (char *) "self",(char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6809     };
6810
6811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:StatusBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6813     if (SWIG_arg_fail(1)) SWIG_fail;
6814     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6815     if (SWIG_arg_fail(2)) SWIG_fail;
6816     if (obj2) {
6817         {
6818             arg3 = (int)(SWIG_As_int(obj2));
6819             if (SWIG_arg_fail(3)) SWIG_fail;
6820         }
6821     }
6822     if (obj3) {
6823         {
6824             arg4 = (long)(SWIG_As_long(obj3));
6825             if (SWIG_arg_fail(4)) SWIG_fail;
6826         }
6827     }
6828     if (obj4) {
6829         {
6830             arg5 = wxString_in_helper(obj4);
6831             if (arg5 == NULL) SWIG_fail;
6832             temp5 = true;
6833         }
6834     }
6835     {
6836         PyThreadState* __tstate = wxPyBeginAllowThreads();
6837         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxString const &)*arg5);
6838
6839         wxPyEndAllowThreads(__tstate);
6840         if (PyErr_Occurred()) SWIG_fail;
6841     }
6842     {
6843         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6844     }
6845     {
6846         if (temp5)
6847         delete arg5;
6848     }
6849     return resultobj;
6850     fail:
6851     {
6852         if (temp5)
6853         delete arg5;
6854     }
6855     return NULL;
6856 }
6857
6858
6859 static PyObject *_wrap_StatusBar_SetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6860     PyObject *resultobj;
6861     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6862     int arg2 = (int) 1 ;
6863     PyObject * obj0 = 0 ;
6864     PyObject * obj1 = 0 ;
6865     char *kwnames[] = {
6866         (char *) "self",(char *) "number", NULL
6867     };
6868
6869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_SetFieldsCount",kwnames,&obj0,&obj1)) goto fail;
6870     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6871     if (SWIG_arg_fail(1)) SWIG_fail;
6872     if (obj1) {
6873         {
6874             arg2 = (int)(SWIG_As_int(obj1));
6875             if (SWIG_arg_fail(2)) SWIG_fail;
6876         }
6877     }
6878     {
6879         PyThreadState* __tstate = wxPyBeginAllowThreads();
6880         (arg1)->SetFieldsCount(arg2);
6881
6882         wxPyEndAllowThreads(__tstate);
6883         if (PyErr_Occurred()) SWIG_fail;
6884     }
6885     Py_INCREF(Py_None); resultobj = Py_None;
6886     return resultobj;
6887     fail:
6888     return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_StatusBar_GetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6893     PyObject *resultobj;
6894     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6895     int result;
6896     PyObject * obj0 = 0 ;
6897     char *kwnames[] = {
6898         (char *) "self", NULL
6899     };
6900
6901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetFieldsCount",kwnames,&obj0)) goto fail;
6902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6903     if (SWIG_arg_fail(1)) SWIG_fail;
6904     {
6905         PyThreadState* __tstate = wxPyBeginAllowThreads();
6906         result = (int)((wxStatusBar const *)arg1)->GetFieldsCount();
6907
6908         wxPyEndAllowThreads(__tstate);
6909         if (PyErr_Occurred()) SWIG_fail;
6910     }
6911     {
6912         resultobj = SWIG_From_int((int)(result));
6913     }
6914     return resultobj;
6915     fail:
6916     return NULL;
6917 }
6918
6919
6920 static PyObject *_wrap_StatusBar_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6921     PyObject *resultobj;
6922     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6923     wxString *arg2 = 0 ;
6924     int arg3 = (int) 0 ;
6925     bool temp2 = false ;
6926     PyObject * obj0 = 0 ;
6927     PyObject * obj1 = 0 ;
6928     PyObject * obj2 = 0 ;
6929     char *kwnames[] = {
6930         (char *) "self",(char *) "text",(char *) "number", NULL
6931     };
6932
6933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
6934     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6935     if (SWIG_arg_fail(1)) SWIG_fail;
6936     {
6937         arg2 = wxString_in_helper(obj1);
6938         if (arg2 == NULL) SWIG_fail;
6939         temp2 = true;
6940     }
6941     if (obj2) {
6942         {
6943             arg3 = (int)(SWIG_As_int(obj2));
6944             if (SWIG_arg_fail(3)) SWIG_fail;
6945         }
6946     }
6947     {
6948         PyThreadState* __tstate = wxPyBeginAllowThreads();
6949         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
6950
6951         wxPyEndAllowThreads(__tstate);
6952         if (PyErr_Occurred()) SWIG_fail;
6953     }
6954     Py_INCREF(Py_None); resultobj = Py_None;
6955     {
6956         if (temp2)
6957         delete arg2;
6958     }
6959     return resultobj;
6960     fail:
6961     {
6962         if (temp2)
6963         delete arg2;
6964     }
6965     return NULL;
6966 }
6967
6968
6969 static PyObject *_wrap_StatusBar_GetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6970     PyObject *resultobj;
6971     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6972     int arg2 = (int) 0 ;
6973     wxString result;
6974     PyObject * obj0 = 0 ;
6975     PyObject * obj1 = 0 ;
6976     char *kwnames[] = {
6977         (char *) "self",(char *) "number", NULL
6978     };
6979
6980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_GetStatusText",kwnames,&obj0,&obj1)) goto fail;
6981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6982     if (SWIG_arg_fail(1)) SWIG_fail;
6983     if (obj1) {
6984         {
6985             arg2 = (int)(SWIG_As_int(obj1));
6986             if (SWIG_arg_fail(2)) SWIG_fail;
6987         }
6988     }
6989     {
6990         PyThreadState* __tstate = wxPyBeginAllowThreads();
6991         result = ((wxStatusBar const *)arg1)->GetStatusText(arg2);
6992
6993         wxPyEndAllowThreads(__tstate);
6994         if (PyErr_Occurred()) SWIG_fail;
6995     }
6996     {
6997 #if wxUSE_UNICODE
6998         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6999 #else
7000         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7001 #endif
7002     }
7003     return resultobj;
7004     fail:
7005     return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_StatusBar_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7010     PyObject *resultobj;
7011     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7012     wxString *arg2 = 0 ;
7013     int arg3 = (int) 0 ;
7014     bool temp2 = false ;
7015     PyObject * obj0 = 0 ;
7016     PyObject * obj1 = 0 ;
7017     PyObject * obj2 = 0 ;
7018     char *kwnames[] = {
7019         (char *) "self",(char *) "text",(char *) "number", NULL
7020     };
7021
7022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
7023     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7024     if (SWIG_arg_fail(1)) SWIG_fail;
7025     {
7026         arg2 = wxString_in_helper(obj1);
7027         if (arg2 == NULL) SWIG_fail;
7028         temp2 = true;
7029     }
7030     if (obj2) {
7031         {
7032             arg3 = (int)(SWIG_As_int(obj2));
7033             if (SWIG_arg_fail(3)) SWIG_fail;
7034         }
7035     }
7036     {
7037         PyThreadState* __tstate = wxPyBeginAllowThreads();
7038         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
7039
7040         wxPyEndAllowThreads(__tstate);
7041         if (PyErr_Occurred()) SWIG_fail;
7042     }
7043     Py_INCREF(Py_None); resultobj = Py_None;
7044     {
7045         if (temp2)
7046         delete arg2;
7047     }
7048     return resultobj;
7049     fail:
7050     {
7051         if (temp2)
7052         delete arg2;
7053     }
7054     return NULL;
7055 }
7056
7057
7058 static PyObject *_wrap_StatusBar_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7059     PyObject *resultobj;
7060     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7061     int arg2 = (int) 0 ;
7062     PyObject * obj0 = 0 ;
7063     PyObject * obj1 = 0 ;
7064     char *kwnames[] = {
7065         (char *) "self",(char *) "number", NULL
7066     };
7067
7068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
7069     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7070     if (SWIG_arg_fail(1)) SWIG_fail;
7071     if (obj1) {
7072         {
7073             arg2 = (int)(SWIG_As_int(obj1));
7074             if (SWIG_arg_fail(2)) SWIG_fail;
7075         }
7076     }
7077     {
7078         PyThreadState* __tstate = wxPyBeginAllowThreads();
7079         (arg1)->PopStatusText(arg2);
7080
7081         wxPyEndAllowThreads(__tstate);
7082         if (PyErr_Occurred()) SWIG_fail;
7083     }
7084     Py_INCREF(Py_None); resultobj = Py_None;
7085     return resultobj;
7086     fail:
7087     return NULL;
7088 }
7089
7090
7091 static PyObject *_wrap_StatusBar_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
7092     PyObject *resultobj;
7093     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7094     int arg2 ;
7095     int *arg3 = (int *) 0 ;
7096     PyObject * obj0 = 0 ;
7097     PyObject * obj1 = 0 ;
7098     char *kwnames[] = {
7099         (char *) "self",(char *) "widths", NULL
7100     };
7101
7102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
7103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7104     if (SWIG_arg_fail(1)) SWIG_fail;
7105     {
7106         arg2 = PyList_Size(obj1);
7107         arg3 =  int_LIST_helper(obj1);
7108         if (arg3 == NULL) SWIG_fail;
7109     }
7110     {
7111         PyThreadState* __tstate = wxPyBeginAllowThreads();
7112         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
7113
7114         wxPyEndAllowThreads(__tstate);
7115         if (PyErr_Occurred()) SWIG_fail;
7116     }
7117     Py_INCREF(Py_None); resultobj = Py_None;
7118     {
7119         if (arg3) delete [] arg3;
7120     }
7121     return resultobj;
7122     fail:
7123     {
7124         if (arg3) delete [] arg3;
7125     }
7126     return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_StatusBar_SetStatusStyles(PyObject *, PyObject *args, PyObject *kwargs) {
7131     PyObject *resultobj;
7132     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7133     int arg2 ;
7134     int *arg3 = (int *) 0 ;
7135     PyObject * obj0 = 0 ;
7136     PyObject * obj1 = 0 ;
7137     char *kwnames[] = {
7138         (char *) "self",(char *) "styles", NULL
7139     };
7140
7141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusStyles",kwnames,&obj0,&obj1)) goto fail;
7142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7143     if (SWIG_arg_fail(1)) SWIG_fail;
7144     {
7145         arg2 = PyList_Size(obj1);
7146         arg3 =  int_LIST_helper(obj1);
7147         if (arg3 == NULL) SWIG_fail;
7148     }
7149     {
7150         PyThreadState* __tstate = wxPyBeginAllowThreads();
7151         (arg1)->SetStatusStyles(arg2,(int const *)arg3);
7152
7153         wxPyEndAllowThreads(__tstate);
7154         if (PyErr_Occurred()) SWIG_fail;
7155     }
7156     Py_INCREF(Py_None); resultobj = Py_None;
7157     {
7158         if (arg3) delete [] arg3;
7159     }
7160     return resultobj;
7161     fail:
7162     {
7163         if (arg3) delete [] arg3;
7164     }
7165     return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *, PyObject *args, PyObject *kwargs) {
7170     PyObject *resultobj;
7171     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7172     int arg2 ;
7173     wxRect result;
7174     PyObject * obj0 = 0 ;
7175     PyObject * obj1 = 0 ;
7176     char *kwnames[] = {
7177         (char *) "self",(char *) "i", NULL
7178     };
7179
7180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_GetFieldRect",kwnames,&obj0,&obj1)) goto fail;
7181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7182     if (SWIG_arg_fail(1)) SWIG_fail;
7183     {
7184         arg2 = (int)(SWIG_As_int(obj1));
7185         if (SWIG_arg_fail(2)) SWIG_fail;
7186     }
7187     {
7188         PyThreadState* __tstate = wxPyBeginAllowThreads();
7189         result = wxStatusBar_GetFieldRect(arg1,arg2);
7190
7191         wxPyEndAllowThreads(__tstate);
7192         if (PyErr_Occurred()) SWIG_fail;
7193     }
7194     {
7195         wxRect * resultptr;
7196         resultptr = new wxRect((wxRect &)(result));
7197         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7198     }
7199     return resultobj;
7200     fail:
7201     return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_StatusBar_SetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7206     PyObject *resultobj;
7207     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7208     int arg2 ;
7209     PyObject * obj0 = 0 ;
7210     PyObject * obj1 = 0 ;
7211     char *kwnames[] = {
7212         (char *) "self",(char *) "height", NULL
7213     };
7214
7215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetMinHeight",kwnames,&obj0,&obj1)) goto fail;
7216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7217     if (SWIG_arg_fail(1)) SWIG_fail;
7218     {
7219         arg2 = (int)(SWIG_As_int(obj1));
7220         if (SWIG_arg_fail(2)) SWIG_fail;
7221     }
7222     {
7223         PyThreadState* __tstate = wxPyBeginAllowThreads();
7224         (arg1)->SetMinHeight(arg2);
7225
7226         wxPyEndAllowThreads(__tstate);
7227         if (PyErr_Occurred()) SWIG_fail;
7228     }
7229     Py_INCREF(Py_None); resultobj = Py_None;
7230     return resultobj;
7231     fail:
7232     return NULL;
7233 }
7234
7235
7236 static PyObject *_wrap_StatusBar_GetBorderX(PyObject *, PyObject *args, PyObject *kwargs) {
7237     PyObject *resultobj;
7238     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7239     int result;
7240     PyObject * obj0 = 0 ;
7241     char *kwnames[] = {
7242         (char *) "self", NULL
7243     };
7244
7245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderX",kwnames,&obj0)) goto fail;
7246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7247     if (SWIG_arg_fail(1)) SWIG_fail;
7248     {
7249         PyThreadState* __tstate = wxPyBeginAllowThreads();
7250         result = (int)((wxStatusBar const *)arg1)->GetBorderX();
7251
7252         wxPyEndAllowThreads(__tstate);
7253         if (PyErr_Occurred()) SWIG_fail;
7254     }
7255     {
7256         resultobj = SWIG_From_int((int)(result));
7257     }
7258     return resultobj;
7259     fail:
7260     return NULL;
7261 }
7262
7263
7264 static PyObject *_wrap_StatusBar_GetBorderY(PyObject *, PyObject *args, PyObject *kwargs) {
7265     PyObject *resultobj;
7266     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7267     int result;
7268     PyObject * obj0 = 0 ;
7269     char *kwnames[] = {
7270         (char *) "self", NULL
7271     };
7272
7273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderY",kwnames,&obj0)) goto fail;
7274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7275     if (SWIG_arg_fail(1)) SWIG_fail;
7276     {
7277         PyThreadState* __tstate = wxPyBeginAllowThreads();
7278         result = (int)((wxStatusBar const *)arg1)->GetBorderY();
7279
7280         wxPyEndAllowThreads(__tstate);
7281         if (PyErr_Occurred()) SWIG_fail;
7282     }
7283     {
7284         resultobj = SWIG_From_int((int)(result));
7285     }
7286     return resultobj;
7287     fail:
7288     return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_StatusBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7293     PyObject *resultobj;
7294     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7295     wxVisualAttributes result;
7296     PyObject * obj0 = 0 ;
7297     char *kwnames[] = {
7298         (char *) "variant", NULL
7299     };
7300
7301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StatusBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7302     if (obj0) {
7303         {
7304             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7305             if (SWIG_arg_fail(1)) SWIG_fail;
7306         }
7307     }
7308     {
7309         if (!wxPyCheckForApp()) SWIG_fail;
7310         PyThreadState* __tstate = wxPyBeginAllowThreads();
7311         result = wxStatusBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
7312
7313         wxPyEndAllowThreads(__tstate);
7314         if (PyErr_Occurred()) SWIG_fail;
7315     }
7316     {
7317         wxVisualAttributes * resultptr;
7318         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7319         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7320     }
7321     return resultobj;
7322     fail:
7323     return NULL;
7324 }
7325
7326
7327 static PyObject * StatusBar_swigregister(PyObject *, PyObject *args) {
7328     PyObject *obj;
7329     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7330     SWIG_TypeClientData(SWIGTYPE_p_wxStatusBar, obj);
7331     Py_INCREF(obj);
7332     return Py_BuildValue((char *)"");
7333 }
7334 static int _wrap_SplitterNameStr_set(PyObject *) {
7335     PyErr_SetString(PyExc_TypeError,"Variable SplitterNameStr is read-only.");
7336     return 1;
7337 }
7338
7339
7340 static PyObject *_wrap_SplitterNameStr_get(void) {
7341     PyObject *pyobj;
7342
7343     {
7344 #if wxUSE_UNICODE
7345         pyobj = PyUnicode_FromWideChar((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7346 #else
7347         pyobj = PyString_FromStringAndSize((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7348 #endif
7349     }
7350     return pyobj;
7351 }
7352
7353
7354 static PyObject *_wrap_new_SplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7355     PyObject *resultobj;
7356     wxWindow *arg1 = (wxWindow *) 0 ;
7357     int arg2 = (int) -1 ;
7358     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7359     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7360     wxSize const &arg4_defvalue = wxDefaultSize ;
7361     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7362     long arg5 = (long) wxSP_3D ;
7363     wxString const &arg6_defvalue = wxPySplitterNameStr ;
7364     wxString *arg6 = (wxString *) &arg6_defvalue ;
7365     wxSplitterWindow *result;
7366     wxPoint temp3 ;
7367     wxSize temp4 ;
7368     bool temp6 = false ;
7369     PyObject * obj0 = 0 ;
7370     PyObject * obj1 = 0 ;
7371     PyObject * obj2 = 0 ;
7372     PyObject * obj3 = 0 ;
7373     PyObject * obj4 = 0 ;
7374     PyObject * obj5 = 0 ;
7375     char *kwnames[] = {
7376         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7377     };
7378
7379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SplitterWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
7380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7381     if (SWIG_arg_fail(1)) SWIG_fail;
7382     if (obj1) {
7383         {
7384             arg2 = (int)(SWIG_As_int(obj1));
7385             if (SWIG_arg_fail(2)) SWIG_fail;
7386         }
7387     }
7388     if (obj2) {
7389         {
7390             arg3 = &temp3;
7391             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7392         }
7393     }
7394     if (obj3) {
7395         {
7396             arg4 = &temp4;
7397             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7398         }
7399     }
7400     if (obj4) {
7401         {
7402             arg5 = (long)(SWIG_As_long(obj4));
7403             if (SWIG_arg_fail(5)) SWIG_fail;
7404         }
7405     }
7406     if (obj5) {
7407         {
7408             arg6 = wxString_in_helper(obj5);
7409             if (arg6 == NULL) SWIG_fail;
7410             temp6 = true;
7411         }
7412     }
7413     {
7414         if (!wxPyCheckForApp()) SWIG_fail;
7415         PyThreadState* __tstate = wxPyBeginAllowThreads();
7416         result = (wxSplitterWindow *)new wxSplitterWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
7417
7418         wxPyEndAllowThreads(__tstate);
7419         if (PyErr_Occurred()) SWIG_fail;
7420     }
7421     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7422     {
7423         if (temp6)
7424         delete arg6;
7425     }
7426     return resultobj;
7427     fail:
7428     {
7429         if (temp6)
7430         delete arg6;
7431     }
7432     return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_new_PreSplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7437     PyObject *resultobj;
7438     wxSplitterWindow *result;
7439     char *kwnames[] = {
7440         NULL
7441     };
7442
7443     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSplitterWindow",kwnames)) goto fail;
7444     {
7445         if (!wxPyCheckForApp()) SWIG_fail;
7446         PyThreadState* __tstate = wxPyBeginAllowThreads();
7447         result = (wxSplitterWindow *)new wxSplitterWindow();
7448
7449         wxPyEndAllowThreads(__tstate);
7450         if (PyErr_Occurred()) SWIG_fail;
7451     }
7452     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7453     return resultobj;
7454     fail:
7455     return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_SplitterWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7460     PyObject *resultobj;
7461     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7462     wxWindow *arg2 = (wxWindow *) 0 ;
7463     int arg3 = (int) -1 ;
7464     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7465     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7466     wxSize const &arg5_defvalue = wxDefaultSize ;
7467     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7468     long arg6 = (long) wxSP_3D ;
7469     wxString const &arg7_defvalue = wxPySplitterNameStr ;
7470     wxString *arg7 = (wxString *) &arg7_defvalue ;
7471     bool result;
7472     wxPoint temp4 ;
7473     wxSize temp5 ;
7474     bool temp7 = false ;
7475     PyObject * obj0 = 0 ;
7476     PyObject * obj1 = 0 ;
7477     PyObject * obj2 = 0 ;
7478     PyObject * obj3 = 0 ;
7479     PyObject * obj4 = 0 ;
7480     PyObject * obj5 = 0 ;
7481     PyObject * obj6 = 0 ;
7482     char *kwnames[] = {
7483         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7484     };
7485
7486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SplitterWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
7487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7488     if (SWIG_arg_fail(1)) SWIG_fail;
7489     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7490     if (SWIG_arg_fail(2)) SWIG_fail;
7491     if (obj2) {
7492         {
7493             arg3 = (int)(SWIG_As_int(obj2));
7494             if (SWIG_arg_fail(3)) SWIG_fail;
7495         }
7496     }
7497     if (obj3) {
7498         {
7499             arg4 = &temp4;
7500             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7501         }
7502     }
7503     if (obj4) {
7504         {
7505             arg5 = &temp5;
7506             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7507         }
7508     }
7509     if (obj5) {
7510         {
7511             arg6 = (long)(SWIG_As_long(obj5));
7512             if (SWIG_arg_fail(6)) SWIG_fail;
7513         }
7514     }
7515     if (obj6) {
7516         {
7517             arg7 = wxString_in_helper(obj6);
7518             if (arg7 == NULL) SWIG_fail;
7519             temp7 = true;
7520         }
7521     }
7522     {
7523         PyThreadState* __tstate = wxPyBeginAllowThreads();
7524         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
7525
7526         wxPyEndAllowThreads(__tstate);
7527         if (PyErr_Occurred()) SWIG_fail;
7528     }
7529     {
7530         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7531     }
7532     {
7533         if (temp7)
7534         delete arg7;
7535     }
7536     return resultobj;
7537     fail:
7538     {
7539         if (temp7)
7540         delete arg7;
7541     }
7542     return NULL;
7543 }
7544
7545
7546 static PyObject *_wrap_SplitterWindow_GetWindow1(PyObject *, PyObject *args, PyObject *kwargs) {
7547     PyObject *resultobj;
7548     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7549     wxWindow *result;
7550     PyObject * obj0 = 0 ;
7551     char *kwnames[] = {
7552         (char *) "self", NULL
7553     };
7554
7555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow1",kwnames,&obj0)) goto fail;
7556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7557     if (SWIG_arg_fail(1)) SWIG_fail;
7558     {
7559         PyThreadState* __tstate = wxPyBeginAllowThreads();
7560         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow1();
7561
7562         wxPyEndAllowThreads(__tstate);
7563         if (PyErr_Occurred()) SWIG_fail;
7564     }
7565     {
7566         resultobj = wxPyMake_wxObject(result, 0);
7567     }
7568     return resultobj;
7569     fail:
7570     return NULL;
7571 }
7572
7573
7574 static PyObject *_wrap_SplitterWindow_GetWindow2(PyObject *, PyObject *args, PyObject *kwargs) {
7575     PyObject *resultobj;
7576     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7577     wxWindow *result;
7578     PyObject * obj0 = 0 ;
7579     char *kwnames[] = {
7580         (char *) "self", NULL
7581     };
7582
7583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow2",kwnames,&obj0)) goto fail;
7584     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7585     if (SWIG_arg_fail(1)) SWIG_fail;
7586     {
7587         PyThreadState* __tstate = wxPyBeginAllowThreads();
7588         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow2();
7589
7590         wxPyEndAllowThreads(__tstate);
7591         if (PyErr_Occurred()) SWIG_fail;
7592     }
7593     {
7594         resultobj = wxPyMake_wxObject(result, 0);
7595     }
7596     return resultobj;
7597     fail:
7598     return NULL;
7599 }
7600
7601
7602 static PyObject *_wrap_SplitterWindow_SetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7603     PyObject *resultobj;
7604     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7605     int arg2 ;
7606     PyObject * obj0 = 0 ;
7607     PyObject * obj1 = 0 ;
7608     char *kwnames[] = {
7609         (char *) "self",(char *) "mode", NULL
7610     };
7611
7612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSplitMode",kwnames,&obj0,&obj1)) goto fail;
7613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7614     if (SWIG_arg_fail(1)) SWIG_fail;
7615     {
7616         arg2 = (int)(SWIG_As_int(obj1));
7617         if (SWIG_arg_fail(2)) SWIG_fail;
7618     }
7619     {
7620         PyThreadState* __tstate = wxPyBeginAllowThreads();
7621         (arg1)->SetSplitMode(arg2);
7622
7623         wxPyEndAllowThreads(__tstate);
7624         if (PyErr_Occurred()) SWIG_fail;
7625     }
7626     Py_INCREF(Py_None); resultobj = Py_None;
7627     return resultobj;
7628     fail:
7629     return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_SplitterWindow_GetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7634     PyObject *resultobj;
7635     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7636     wxSplitMode result;
7637     PyObject * obj0 = 0 ;
7638     char *kwnames[] = {
7639         (char *) "self", NULL
7640     };
7641
7642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSplitMode",kwnames,&obj0)) goto fail;
7643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7644     if (SWIG_arg_fail(1)) SWIG_fail;
7645     {
7646         PyThreadState* __tstate = wxPyBeginAllowThreads();
7647         result = (wxSplitMode)((wxSplitterWindow const *)arg1)->GetSplitMode();
7648
7649         wxPyEndAllowThreads(__tstate);
7650         if (PyErr_Occurred()) SWIG_fail;
7651     }
7652     resultobj = SWIG_From_int((result));
7653     return resultobj;
7654     fail:
7655     return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_SplitterWindow_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
7660     PyObject *resultobj;
7661     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7662     wxWindow *arg2 = (wxWindow *) 0 ;
7663     PyObject * obj0 = 0 ;
7664     PyObject * obj1 = 0 ;
7665     char *kwnames[] = {
7666         (char *) "self",(char *) "window", NULL
7667     };
7668
7669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_Initialize",kwnames,&obj0,&obj1)) goto fail;
7670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7671     if (SWIG_arg_fail(1)) SWIG_fail;
7672     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7673     if (SWIG_arg_fail(2)) SWIG_fail;
7674     {
7675         PyThreadState* __tstate = wxPyBeginAllowThreads();
7676         (arg1)->Initialize(arg2);
7677
7678         wxPyEndAllowThreads(__tstate);
7679         if (PyErr_Occurred()) SWIG_fail;
7680     }
7681     Py_INCREF(Py_None); resultobj = Py_None;
7682     return resultobj;
7683     fail:
7684     return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_SplitterWindow_SplitVertically(PyObject *, PyObject *args, PyObject *kwargs) {
7689     PyObject *resultobj;
7690     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7691     wxWindow *arg2 = (wxWindow *) 0 ;
7692     wxWindow *arg3 = (wxWindow *) 0 ;
7693     int arg4 = (int) 0 ;
7694     bool result;
7695     PyObject * obj0 = 0 ;
7696     PyObject * obj1 = 0 ;
7697     PyObject * obj2 = 0 ;
7698     PyObject * obj3 = 0 ;
7699     char *kwnames[] = {
7700         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7701     };
7702
7703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitVertically",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7705     if (SWIG_arg_fail(1)) SWIG_fail;
7706     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7707     if (SWIG_arg_fail(2)) SWIG_fail;
7708     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7709     if (SWIG_arg_fail(3)) SWIG_fail;
7710     if (obj3) {
7711         {
7712             arg4 = (int)(SWIG_As_int(obj3));
7713             if (SWIG_arg_fail(4)) SWIG_fail;
7714         }
7715     }
7716     {
7717         PyThreadState* __tstate = wxPyBeginAllowThreads();
7718         result = (bool)(arg1)->SplitVertically(arg2,arg3,arg4);
7719
7720         wxPyEndAllowThreads(__tstate);
7721         if (PyErr_Occurred()) SWIG_fail;
7722     }
7723     {
7724         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725     }
7726     return resultobj;
7727     fail:
7728     return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_SplitterWindow_SplitHorizontally(PyObject *, PyObject *args, PyObject *kwargs) {
7733     PyObject *resultobj;
7734     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7735     wxWindow *arg2 = (wxWindow *) 0 ;
7736     wxWindow *arg3 = (wxWindow *) 0 ;
7737     int arg4 = (int) 0 ;
7738     bool result;
7739     PyObject * obj0 = 0 ;
7740     PyObject * obj1 = 0 ;
7741     PyObject * obj2 = 0 ;
7742     PyObject * obj3 = 0 ;
7743     char *kwnames[] = {
7744         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7745     };
7746
7747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitHorizontally",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7749     if (SWIG_arg_fail(1)) SWIG_fail;
7750     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7751     if (SWIG_arg_fail(2)) SWIG_fail;
7752     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7753     if (SWIG_arg_fail(3)) SWIG_fail;
7754     if (obj3) {
7755         {
7756             arg4 = (int)(SWIG_As_int(obj3));
7757             if (SWIG_arg_fail(4)) SWIG_fail;
7758         }
7759     }
7760     {
7761         PyThreadState* __tstate = wxPyBeginAllowThreads();
7762         result = (bool)(arg1)->SplitHorizontally(arg2,arg3,arg4);
7763
7764         wxPyEndAllowThreads(__tstate);
7765         if (PyErr_Occurred()) SWIG_fail;
7766     }
7767     {
7768         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769     }
7770     return resultobj;
7771     fail:
7772     return NULL;
7773 }
7774
7775
7776 static PyObject *_wrap_SplitterWindow_Unsplit(PyObject *, PyObject *args, PyObject *kwargs) {
7777     PyObject *resultobj;
7778     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7779     wxWindow *arg2 = (wxWindow *) NULL ;
7780     bool result;
7781     PyObject * obj0 = 0 ;
7782     PyObject * obj1 = 0 ;
7783     char *kwnames[] = {
7784         (char *) "self",(char *) "toRemove", NULL
7785     };
7786
7787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SplitterWindow_Unsplit",kwnames,&obj0,&obj1)) goto fail;
7788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7789     if (SWIG_arg_fail(1)) SWIG_fail;
7790     if (obj1) {
7791         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7792         if (SWIG_arg_fail(2)) SWIG_fail;
7793     }
7794     {
7795         PyThreadState* __tstate = wxPyBeginAllowThreads();
7796         result = (bool)(arg1)->Unsplit(arg2);
7797
7798         wxPyEndAllowThreads(__tstate);
7799         if (PyErr_Occurred()) SWIG_fail;
7800     }
7801     {
7802         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7803     }
7804     return resultobj;
7805     fail:
7806     return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7811     PyObject *resultobj;
7812     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7813     wxWindow *arg2 = (wxWindow *) 0 ;
7814     wxWindow *arg3 = (wxWindow *) 0 ;
7815     bool result;
7816     PyObject * obj0 = 0 ;
7817     PyObject * obj1 = 0 ;
7818     PyObject * obj2 = 0 ;
7819     char *kwnames[] = {
7820         (char *) "self",(char *) "winOld",(char *) "winNew", NULL
7821     };
7822
7823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SplitterWindow_ReplaceWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
7824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7825     if (SWIG_arg_fail(1)) SWIG_fail;
7826     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7827     if (SWIG_arg_fail(2)) SWIG_fail;
7828     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7829     if (SWIG_arg_fail(3)) SWIG_fail;
7830     {
7831         PyThreadState* __tstate = wxPyBeginAllowThreads();
7832         result = (bool)(arg1)->ReplaceWindow(arg2,arg3);
7833
7834         wxPyEndAllowThreads(__tstate);
7835         if (PyErr_Occurred()) SWIG_fail;
7836     }
7837     {
7838         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839     }
7840     return resultobj;
7841     fail:
7842     return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *, PyObject *args, PyObject *kwargs) {
7847     PyObject *resultobj;
7848     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7849     PyObject * obj0 = 0 ;
7850     char *kwnames[] = {
7851         (char *) "self", NULL
7852     };
7853
7854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail;
7855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7856     if (SWIG_arg_fail(1)) SWIG_fail;
7857     {
7858         PyThreadState* __tstate = wxPyBeginAllowThreads();
7859         (arg1)->UpdateSize();
7860
7861         wxPyEndAllowThreads(__tstate);
7862         if (PyErr_Occurred()) SWIG_fail;
7863     }
7864     Py_INCREF(Py_None); resultobj = Py_None;
7865     return resultobj;
7866     fail:
7867     return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *, PyObject *args, PyObject *kwargs) {
7872     PyObject *resultobj;
7873     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7874     bool result;
7875     PyObject * obj0 = 0 ;
7876     char *kwnames[] = {
7877         (char *) "self", NULL
7878     };
7879
7880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_IsSplit",kwnames,&obj0)) goto fail;
7881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7882     if (SWIG_arg_fail(1)) SWIG_fail;
7883     {
7884         PyThreadState* __tstate = wxPyBeginAllowThreads();
7885         result = (bool)((wxSplitterWindow const *)arg1)->IsSplit();
7886
7887         wxPyEndAllowThreads(__tstate);
7888         if (PyErr_Occurred()) SWIG_fail;
7889     }
7890     {
7891         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7892     }
7893     return resultobj;
7894     fail:
7895     return NULL;
7896 }
7897
7898
7899 static PyObject *_wrap_SplitterWindow_SetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7900     PyObject *resultobj;
7901     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7902     int arg2 ;
7903     PyObject * obj0 = 0 ;
7904     PyObject * obj1 = 0 ;
7905     char *kwnames[] = {
7906         (char *) "self",(char *) "width", NULL
7907     };
7908
7909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashSize",kwnames,&obj0,&obj1)) goto fail;
7910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7911     if (SWIG_arg_fail(1)) SWIG_fail;
7912     {
7913         arg2 = (int)(SWIG_As_int(obj1));
7914         if (SWIG_arg_fail(2)) SWIG_fail;
7915     }
7916     {
7917         PyThreadState* __tstate = wxPyBeginAllowThreads();
7918         (arg1)->SetSashSize(arg2);
7919
7920         wxPyEndAllowThreads(__tstate);
7921         if (PyErr_Occurred()) SWIG_fail;
7922     }
7923     Py_INCREF(Py_None); resultobj = Py_None;
7924     return resultobj;
7925     fail:
7926     return NULL;
7927 }
7928
7929
7930 static PyObject *_wrap_SplitterWindow_SetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7931     PyObject *resultobj;
7932     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7933     int arg2 ;
7934     PyObject * obj0 = 0 ;
7935     PyObject * obj1 = 0 ;
7936     char *kwnames[] = {
7937         (char *) "self",(char *) "width", NULL
7938     };
7939
7940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetBorderSize",kwnames,&obj0,&obj1)) goto fail;
7941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, 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)->SetBorderSize(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_SplitterWindow_GetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7962     PyObject *resultobj;
7963     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7964     int result;
7965     PyObject * obj0 = 0 ;
7966     char *kwnames[] = {
7967         (char *) "self", NULL
7968     };
7969
7970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashSize",kwnames,&obj0)) goto fail;
7971     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7972     if (SWIG_arg_fail(1)) SWIG_fail;
7973     {
7974         PyThreadState* __tstate = wxPyBeginAllowThreads();
7975         result = (int)((wxSplitterWindow const *)arg1)->GetSashSize();
7976
7977         wxPyEndAllowThreads(__tstate);
7978         if (PyErr_Occurred()) SWIG_fail;
7979     }
7980     {
7981         resultobj = SWIG_From_int((int)(result));
7982     }
7983     return resultobj;
7984     fail:
7985     return NULL;
7986 }
7987
7988
7989 static PyObject *_wrap_SplitterWindow_GetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7990     PyObject *resultobj;
7991     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7992     int result;
7993     PyObject * obj0 = 0 ;
7994     char *kwnames[] = {
7995         (char *) "self", NULL
7996     };
7997
7998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetBorderSize",kwnames,&obj0)) goto fail;
7999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8000     if (SWIG_arg_fail(1)) SWIG_fail;
8001     {
8002         PyThreadState* __tstate = wxPyBeginAllowThreads();
8003         result = (int)((wxSplitterWindow const *)arg1)->GetBorderSize();
8004
8005         wxPyEndAllowThreads(__tstate);
8006         if (PyErr_Occurred()) SWIG_fail;
8007     }
8008     {
8009         resultobj = SWIG_From_int((int)(result));
8010     }
8011     return resultobj;
8012     fail:
8013     return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_SplitterWindow_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8018     PyObject *resultobj;
8019     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8020     int arg2 ;
8021     bool arg3 = (bool) true ;
8022     PyObject * obj0 = 0 ;
8023     PyObject * obj1 = 0 ;
8024     PyObject * obj2 = 0 ;
8025     char *kwnames[] = {
8026         (char *) "self",(char *) "position",(char *) "redraw", NULL
8027     };
8028
8029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SplitterWindow_SetSashPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
8030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8031     if (SWIG_arg_fail(1)) SWIG_fail;
8032     {
8033         arg2 = (int)(SWIG_As_int(obj1));
8034         if (SWIG_arg_fail(2)) SWIG_fail;
8035     }
8036     if (obj2) {
8037         {
8038             arg3 = (bool)(SWIG_As_bool(obj2));
8039             if (SWIG_arg_fail(3)) SWIG_fail;
8040         }
8041     }
8042     {
8043         PyThreadState* __tstate = wxPyBeginAllowThreads();
8044         (arg1)->SetSashPosition(arg2,arg3);
8045
8046         wxPyEndAllowThreads(__tstate);
8047         if (PyErr_Occurred()) SWIG_fail;
8048     }
8049     Py_INCREF(Py_None); resultobj = Py_None;
8050     return resultobj;
8051     fail:
8052     return NULL;
8053 }
8054
8055
8056 static PyObject *_wrap_SplitterWindow_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8057     PyObject *resultobj;
8058     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8059     int result;
8060     PyObject * obj0 = 0 ;
8061     char *kwnames[] = {
8062         (char *) "self", NULL
8063     };
8064
8065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashPosition",kwnames,&obj0)) goto fail;
8066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8067     if (SWIG_arg_fail(1)) SWIG_fail;
8068     {
8069         PyThreadState* __tstate = wxPyBeginAllowThreads();
8070         result = (int)((wxSplitterWindow const *)arg1)->GetSashPosition();
8071
8072         wxPyEndAllowThreads(__tstate);
8073         if (PyErr_Occurred()) SWIG_fail;
8074     }
8075     {
8076         resultobj = SWIG_From_int((int)(result));
8077     }
8078     return resultobj;
8079     fail:
8080     return NULL;
8081 }
8082
8083
8084 static PyObject *_wrap_SplitterWindow_SetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8085     PyObject *resultobj;
8086     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8087     double arg2 ;
8088     PyObject * obj0 = 0 ;
8089     PyObject * obj1 = 0 ;
8090     char *kwnames[] = {
8091         (char *) "self",(char *) "gravity", NULL
8092     };
8093
8094     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashGravity",kwnames,&obj0,&obj1)) goto fail;
8095     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8096     if (SWIG_arg_fail(1)) SWIG_fail;
8097     {
8098         arg2 = (double)(SWIG_As_double(obj1));
8099         if (SWIG_arg_fail(2)) SWIG_fail;
8100     }
8101     {
8102         PyThreadState* __tstate = wxPyBeginAllowThreads();
8103         (arg1)->SetSashGravity(arg2);
8104
8105         wxPyEndAllowThreads(__tstate);
8106         if (PyErr_Occurred()) SWIG_fail;
8107     }
8108     Py_INCREF(Py_None); resultobj = Py_None;
8109     return resultobj;
8110     fail:
8111     return NULL;
8112 }
8113
8114
8115 static PyObject *_wrap_SplitterWindow_GetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8116     PyObject *resultobj;
8117     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8118     double result;
8119     PyObject * obj0 = 0 ;
8120     char *kwnames[] = {
8121         (char *) "self", NULL
8122     };
8123
8124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashGravity",kwnames,&obj0)) goto fail;
8125     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8126     if (SWIG_arg_fail(1)) SWIG_fail;
8127     {
8128         PyThreadState* __tstate = wxPyBeginAllowThreads();
8129         result = (double)((wxSplitterWindow const *)arg1)->GetSashGravity();
8130
8131         wxPyEndAllowThreads(__tstate);
8132         if (PyErr_Occurred()) SWIG_fail;
8133     }
8134     {
8135         resultobj = SWIG_From_double((double)(result));
8136     }
8137     return resultobj;
8138     fail:
8139     return NULL;
8140 }
8141
8142
8143 static PyObject *_wrap_SplitterWindow_SetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8144     PyObject *resultobj;
8145     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8146     int arg2 ;
8147     PyObject * obj0 = 0 ;
8148     PyObject * obj1 = 0 ;
8149     char *kwnames[] = {
8150         (char *) "self",(char *) "min", NULL
8151     };
8152
8153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetMinimumPaneSize",kwnames,&obj0,&obj1)) goto fail;
8154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
8162         (arg1)->SetMinimumPaneSize(arg2);
8163
8164         wxPyEndAllowThreads(__tstate);
8165         if (PyErr_Occurred()) SWIG_fail;
8166     }
8167     Py_INCREF(Py_None); resultobj = Py_None;
8168     return resultobj;
8169     fail:
8170     return NULL;
8171 }
8172
8173
8174 static PyObject *_wrap_SplitterWindow_GetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8175     PyObject *resultobj;
8176     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8177     int result;
8178     PyObject * obj0 = 0 ;
8179     char *kwnames[] = {
8180         (char *) "self", NULL
8181     };
8182
8183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetMinimumPaneSize",kwnames,&obj0)) goto fail;
8184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8185     if (SWIG_arg_fail(1)) SWIG_fail;
8186     {
8187         PyThreadState* __tstate = wxPyBeginAllowThreads();
8188         result = (int)((wxSplitterWindow const *)arg1)->GetMinimumPaneSize();
8189
8190         wxPyEndAllowThreads(__tstate);
8191         if (PyErr_Occurred()) SWIG_fail;
8192     }
8193     {
8194         resultobj = SWIG_From_int((int)(result));
8195     }
8196     return resultobj;
8197     fail:
8198     return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_SplitterWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8203     PyObject *resultobj;
8204     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8205     int arg2 ;
8206     int arg3 ;
8207     int arg4 = (int) 5 ;
8208     bool result;
8209     PyObject * obj0 = 0 ;
8210     PyObject * obj1 = 0 ;
8211     PyObject * obj2 = 0 ;
8212     PyObject * obj3 = 0 ;
8213     char *kwnames[] = {
8214         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
8215     };
8216
8217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8218     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8219     if (SWIG_arg_fail(1)) SWIG_fail;
8220     {
8221         arg2 = (int)(SWIG_As_int(obj1));
8222         if (SWIG_arg_fail(2)) SWIG_fail;
8223     }
8224     {
8225         arg3 = (int)(SWIG_As_int(obj2));
8226         if (SWIG_arg_fail(3)) SWIG_fail;
8227     }
8228     if (obj3) {
8229         {
8230             arg4 = (int)(SWIG_As_int(obj3));
8231             if (SWIG_arg_fail(4)) SWIG_fail;
8232         }
8233     }
8234     {
8235         PyThreadState* __tstate = wxPyBeginAllowThreads();
8236         result = (bool)(arg1)->SashHitTest(arg2,arg3,arg4);
8237
8238         wxPyEndAllowThreads(__tstate);
8239         if (PyErr_Occurred()) SWIG_fail;
8240     }
8241     {
8242         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8243     }
8244     return resultobj;
8245     fail:
8246     return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_SplitterWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
8251     PyObject *resultobj;
8252     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8253     PyObject * obj0 = 0 ;
8254     char *kwnames[] = {
8255         (char *) "self", NULL
8256     };
8257
8258     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_SizeWindows",kwnames,&obj0)) goto fail;
8259     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8260     if (SWIG_arg_fail(1)) SWIG_fail;
8261     {
8262         PyThreadState* __tstate = wxPyBeginAllowThreads();
8263         (arg1)->SizeWindows();
8264
8265         wxPyEndAllowThreads(__tstate);
8266         if (PyErr_Occurred()) SWIG_fail;
8267     }
8268     Py_INCREF(Py_None); resultobj = Py_None;
8269     return resultobj;
8270     fail:
8271     return NULL;
8272 }
8273
8274
8275 static PyObject *_wrap_SplitterWindow_SetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8276     PyObject *resultobj;
8277     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8278     bool arg2 ;
8279     PyObject * obj0 = 0 ;
8280     PyObject * obj1 = 0 ;
8281     char *kwnames[] = {
8282         (char *) "self",(char *) "needUpdating", NULL
8283     };
8284
8285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetNeedUpdating",kwnames,&obj0,&obj1)) goto fail;
8286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8287     if (SWIG_arg_fail(1)) SWIG_fail;
8288     {
8289         arg2 = (bool)(SWIG_As_bool(obj1));
8290         if (SWIG_arg_fail(2)) SWIG_fail;
8291     }
8292     {
8293         PyThreadState* __tstate = wxPyBeginAllowThreads();
8294         (arg1)->SetNeedUpdating(arg2);
8295
8296         wxPyEndAllowThreads(__tstate);
8297         if (PyErr_Occurred()) SWIG_fail;
8298     }
8299     Py_INCREF(Py_None); resultobj = Py_None;
8300     return resultobj;
8301     fail:
8302     return NULL;
8303 }
8304
8305
8306 static PyObject *_wrap_SplitterWindow_GetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8307     PyObject *resultobj;
8308     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8309     bool result;
8310     PyObject * obj0 = 0 ;
8311     char *kwnames[] = {
8312         (char *) "self", NULL
8313     };
8314
8315     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetNeedUpdating",kwnames,&obj0)) goto fail;
8316     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8317     if (SWIG_arg_fail(1)) SWIG_fail;
8318     {
8319         PyThreadState* __tstate = wxPyBeginAllowThreads();
8320         result = (bool)((wxSplitterWindow const *)arg1)->GetNeedUpdating();
8321
8322         wxPyEndAllowThreads(__tstate);
8323         if (PyErr_Occurred()) SWIG_fail;
8324     }
8325     {
8326         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327     }
8328     return resultobj;
8329     fail:
8330     return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_SplitterWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8335     PyObject *resultobj;
8336     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8337     wxVisualAttributes result;
8338     PyObject * obj0 = 0 ;
8339     char *kwnames[] = {
8340         (char *) "variant", NULL
8341     };
8342
8343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SplitterWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8344     if (obj0) {
8345         {
8346             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8347             if (SWIG_arg_fail(1)) SWIG_fail;
8348         }
8349     }
8350     {
8351         if (!wxPyCheckForApp()) SWIG_fail;
8352         PyThreadState* __tstate = wxPyBeginAllowThreads();
8353         result = wxSplitterWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
8354
8355         wxPyEndAllowThreads(__tstate);
8356         if (PyErr_Occurred()) SWIG_fail;
8357     }
8358     {
8359         wxVisualAttributes * resultptr;
8360         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8361         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8362     }
8363     return resultobj;
8364     fail:
8365     return NULL;
8366 }
8367
8368
8369 static PyObject * SplitterWindow_swigregister(PyObject *, PyObject *args) {
8370     PyObject *obj;
8371     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8372     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterWindow, obj);
8373     Py_INCREF(obj);
8374     return Py_BuildValue((char *)"");
8375 }
8376 static PyObject *_wrap_new_SplitterEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8377     PyObject *resultobj;
8378     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
8379     wxSplitterWindow *arg2 = (wxSplitterWindow *) (wxSplitterWindow *) NULL ;
8380     wxSplitterEvent *result;
8381     PyObject * obj0 = 0 ;
8382     PyObject * obj1 = 0 ;
8383     char *kwnames[] = {
8384         (char *) "type",(char *) "splitter", NULL
8385     };
8386
8387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SplitterEvent",kwnames,&obj0,&obj1)) goto fail;
8388     if (obj0) {
8389         {
8390             arg1 = (wxEventType)(SWIG_As_int(obj0));
8391             if (SWIG_arg_fail(1)) SWIG_fail;
8392         }
8393     }
8394     if (obj1) {
8395         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8396         if (SWIG_arg_fail(2)) SWIG_fail;
8397     }
8398     {
8399         PyThreadState* __tstate = wxPyBeginAllowThreads();
8400         result = (wxSplitterEvent *)new wxSplitterEvent(arg1,arg2);
8401
8402         wxPyEndAllowThreads(__tstate);
8403         if (PyErr_Occurred()) SWIG_fail;
8404     }
8405     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterEvent, 1);
8406     return resultobj;
8407     fail:
8408     return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_SplitterEvent_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8413     PyObject *resultobj;
8414     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8415     int arg2 ;
8416     PyObject * obj0 = 0 ;
8417     PyObject * obj1 = 0 ;
8418     char *kwnames[] = {
8419         (char *) "self",(char *) "pos", NULL
8420     };
8421
8422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterEvent_SetSashPosition",kwnames,&obj0,&obj1)) goto fail;
8423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8424     if (SWIG_arg_fail(1)) SWIG_fail;
8425     {
8426         arg2 = (int)(SWIG_As_int(obj1));
8427         if (SWIG_arg_fail(2)) SWIG_fail;
8428     }
8429     {
8430         PyThreadState* __tstate = wxPyBeginAllowThreads();
8431         (arg1)->SetSashPosition(arg2);
8432
8433         wxPyEndAllowThreads(__tstate);
8434         if (PyErr_Occurred()) SWIG_fail;
8435     }
8436     Py_INCREF(Py_None); resultobj = Py_None;
8437     return resultobj;
8438     fail:
8439     return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_SplitterEvent_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8444     PyObject *resultobj;
8445     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8446     int result;
8447     PyObject * obj0 = 0 ;
8448     char *kwnames[] = {
8449         (char *) "self", NULL
8450     };
8451
8452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetSashPosition",kwnames,&obj0)) goto fail;
8453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8454     if (SWIG_arg_fail(1)) SWIG_fail;
8455     {
8456         PyThreadState* __tstate = wxPyBeginAllowThreads();
8457         result = (int)((wxSplitterEvent const *)arg1)->GetSashPosition();
8458
8459         wxPyEndAllowThreads(__tstate);
8460         if (PyErr_Occurred()) SWIG_fail;
8461     }
8462     {
8463         resultobj = SWIG_From_int((int)(result));
8464     }
8465     return resultobj;
8466     fail:
8467     return NULL;
8468 }
8469
8470
8471 static PyObject *_wrap_SplitterEvent_GetWindowBeingRemoved(PyObject *, PyObject *args, PyObject *kwargs) {
8472     PyObject *resultobj;
8473     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8474     wxWindow *result;
8475     PyObject * obj0 = 0 ;
8476     char *kwnames[] = {
8477         (char *) "self", NULL
8478     };
8479
8480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetWindowBeingRemoved",kwnames,&obj0)) goto fail;
8481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8482     if (SWIG_arg_fail(1)) SWIG_fail;
8483     {
8484         PyThreadState* __tstate = wxPyBeginAllowThreads();
8485         result = (wxWindow *)((wxSplitterEvent const *)arg1)->GetWindowBeingRemoved();
8486
8487         wxPyEndAllowThreads(__tstate);
8488         if (PyErr_Occurred()) SWIG_fail;
8489     }
8490     {
8491         resultobj = wxPyMake_wxObject(result, 0);
8492     }
8493     return resultobj;
8494     fail:
8495     return NULL;
8496 }
8497
8498
8499 static PyObject *_wrap_SplitterEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
8500     PyObject *resultobj;
8501     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8502     int result;
8503     PyObject * obj0 = 0 ;
8504     char *kwnames[] = {
8505         (char *) "self", NULL
8506     };
8507
8508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetX",kwnames,&obj0)) goto fail;
8509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8510     if (SWIG_arg_fail(1)) SWIG_fail;
8511     {
8512         PyThreadState* __tstate = wxPyBeginAllowThreads();
8513         result = (int)((wxSplitterEvent const *)arg1)->GetX();
8514
8515         wxPyEndAllowThreads(__tstate);
8516         if (PyErr_Occurred()) SWIG_fail;
8517     }
8518     {
8519         resultobj = SWIG_From_int((int)(result));
8520     }
8521     return resultobj;
8522     fail:
8523     return NULL;
8524 }
8525
8526
8527 static PyObject *_wrap_SplitterEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
8528     PyObject *resultobj;
8529     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8530     int result;
8531     PyObject * obj0 = 0 ;
8532     char *kwnames[] = {
8533         (char *) "self", NULL
8534     };
8535
8536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetY",kwnames,&obj0)) goto fail;
8537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8538     if (SWIG_arg_fail(1)) SWIG_fail;
8539     {
8540         PyThreadState* __tstate = wxPyBeginAllowThreads();
8541         result = (int)((wxSplitterEvent const *)arg1)->GetY();
8542
8543         wxPyEndAllowThreads(__tstate);
8544         if (PyErr_Occurred()) SWIG_fail;
8545     }
8546     {
8547         resultobj = SWIG_From_int((int)(result));
8548     }
8549     return resultobj;
8550     fail:
8551     return NULL;
8552 }
8553
8554
8555 static PyObject * SplitterEvent_swigregister(PyObject *, PyObject *args) {
8556     PyObject *obj;
8557     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8558     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterEvent, obj);
8559     Py_INCREF(obj);
8560     return Py_BuildValue((char *)"");
8561 }
8562 static int _wrap_SashNameStr_set(PyObject *) {
8563     PyErr_SetString(PyExc_TypeError,"Variable SashNameStr is read-only.");
8564     return 1;
8565 }
8566
8567
8568 static PyObject *_wrap_SashNameStr_get(void) {
8569     PyObject *pyobj;
8570
8571     {
8572 #if wxUSE_UNICODE
8573         pyobj = PyUnicode_FromWideChar((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8574 #else
8575         pyobj = PyString_FromStringAndSize((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8576 #endif
8577     }
8578     return pyobj;
8579 }
8580
8581
8582 static int _wrap_SashLayoutNameStr_set(PyObject *) {
8583     PyErr_SetString(PyExc_TypeError,"Variable SashLayoutNameStr is read-only.");
8584     return 1;
8585 }
8586
8587
8588 static PyObject *_wrap_SashLayoutNameStr_get(void) {
8589     PyObject *pyobj;
8590
8591     {
8592 #if wxUSE_UNICODE
8593         pyobj = PyUnicode_FromWideChar((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8594 #else
8595         pyobj = PyString_FromStringAndSize((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8596 #endif
8597     }
8598     return pyobj;
8599 }
8600
8601
8602 static PyObject *_wrap_new_SashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8603     PyObject *resultobj;
8604     wxWindow *arg1 = (wxWindow *) 0 ;
8605     int arg2 = (int) -1 ;
8606     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8607     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8608     wxSize const &arg4_defvalue = wxDefaultSize ;
8609     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8610     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8611     wxString const &arg6_defvalue = wxPySashNameStr ;
8612     wxString *arg6 = (wxString *) &arg6_defvalue ;
8613     wxSashWindow *result;
8614     wxPoint temp3 ;
8615     wxSize temp4 ;
8616     bool temp6 = false ;
8617     PyObject * obj0 = 0 ;
8618     PyObject * obj1 = 0 ;
8619     PyObject * obj2 = 0 ;
8620     PyObject * obj3 = 0 ;
8621     PyObject * obj4 = 0 ;
8622     PyObject * obj5 = 0 ;
8623     char *kwnames[] = {
8624         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8625     };
8626
8627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
8628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8629     if (SWIG_arg_fail(1)) SWIG_fail;
8630     if (obj1) {
8631         {
8632             arg2 = (int)(SWIG_As_int(obj1));
8633             if (SWIG_arg_fail(2)) SWIG_fail;
8634         }
8635     }
8636     if (obj2) {
8637         {
8638             arg3 = &temp3;
8639             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8640         }
8641     }
8642     if (obj3) {
8643         {
8644             arg4 = &temp4;
8645             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8646         }
8647     }
8648     if (obj4) {
8649         {
8650             arg5 = (long)(SWIG_As_long(obj4));
8651             if (SWIG_arg_fail(5)) SWIG_fail;
8652         }
8653     }
8654     if (obj5) {
8655         {
8656             arg6 = wxString_in_helper(obj5);
8657             if (arg6 == NULL) SWIG_fail;
8658             temp6 = true;
8659         }
8660     }
8661     {
8662         if (!wxPyCheckForApp()) SWIG_fail;
8663         PyThreadState* __tstate = wxPyBeginAllowThreads();
8664         result = (wxSashWindow *)new wxSashWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
8665
8666         wxPyEndAllowThreads(__tstate);
8667         if (PyErr_Occurred()) SWIG_fail;
8668     }
8669     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8670     {
8671         if (temp6)
8672         delete arg6;
8673     }
8674     return resultobj;
8675     fail:
8676     {
8677         if (temp6)
8678         delete arg6;
8679     }
8680     return NULL;
8681 }
8682
8683
8684 static PyObject *_wrap_new_PreSashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8685     PyObject *resultobj;
8686     wxSashWindow *result;
8687     char *kwnames[] = {
8688         NULL
8689     };
8690
8691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashWindow",kwnames)) goto fail;
8692     {
8693         if (!wxPyCheckForApp()) SWIG_fail;
8694         PyThreadState* __tstate = wxPyBeginAllowThreads();
8695         result = (wxSashWindow *)new wxSashWindow();
8696
8697         wxPyEndAllowThreads(__tstate);
8698         if (PyErr_Occurred()) SWIG_fail;
8699     }
8700     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8701     return resultobj;
8702     fail:
8703     return NULL;
8704 }
8705
8706
8707 static PyObject *_wrap_SashWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8708     PyObject *resultobj;
8709     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8710     wxWindow *arg2 = (wxWindow *) 0 ;
8711     int arg3 = (int) -1 ;
8712     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8713     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8714     wxSize const &arg5_defvalue = wxDefaultSize ;
8715     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8716     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8717     wxString const &arg7_defvalue = wxPySashNameStr ;
8718     wxString *arg7 = (wxString *) &arg7_defvalue ;
8719     bool result;
8720     wxPoint temp4 ;
8721     wxSize temp5 ;
8722     bool temp7 = false ;
8723     PyObject * obj0 = 0 ;
8724     PyObject * obj1 = 0 ;
8725     PyObject * obj2 = 0 ;
8726     PyObject * obj3 = 0 ;
8727     PyObject * obj4 = 0 ;
8728     PyObject * obj5 = 0 ;
8729     PyObject * obj6 = 0 ;
8730     char *kwnames[] = {
8731         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8732     };
8733
8734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
8735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8736     if (SWIG_arg_fail(1)) SWIG_fail;
8737     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8738     if (SWIG_arg_fail(2)) SWIG_fail;
8739     if (obj2) {
8740         {
8741             arg3 = (int)(SWIG_As_int(obj2));
8742             if (SWIG_arg_fail(3)) SWIG_fail;
8743         }
8744     }
8745     if (obj3) {
8746         {
8747             arg4 = &temp4;
8748             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8749         }
8750     }
8751     if (obj4) {
8752         {
8753             arg5 = &temp5;
8754             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8755         }
8756     }
8757     if (obj5) {
8758         {
8759             arg6 = (long)(SWIG_As_long(obj5));
8760             if (SWIG_arg_fail(6)) SWIG_fail;
8761         }
8762     }
8763     if (obj6) {
8764         {
8765             arg7 = wxString_in_helper(obj6);
8766             if (arg7 == NULL) SWIG_fail;
8767             temp7 = true;
8768         }
8769     }
8770     {
8771         PyThreadState* __tstate = wxPyBeginAllowThreads();
8772         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
8773
8774         wxPyEndAllowThreads(__tstate);
8775         if (PyErr_Occurred()) SWIG_fail;
8776     }
8777     {
8778         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8779     }
8780     {
8781         if (temp7)
8782         delete arg7;
8783     }
8784     return resultobj;
8785     fail:
8786     {
8787         if (temp7)
8788         delete arg7;
8789     }
8790     return NULL;
8791 }
8792
8793
8794 static PyObject *_wrap_SashWindow_SetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8795     PyObject *resultobj;
8796     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8797     wxSashEdgePosition arg2 ;
8798     bool arg3 ;
8799     PyObject * obj0 = 0 ;
8800     PyObject * obj1 = 0 ;
8801     PyObject * obj2 = 0 ;
8802     char *kwnames[] = {
8803         (char *) "self",(char *) "edge",(char *) "sash", NULL
8804     };
8805
8806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8808     if (SWIG_arg_fail(1)) SWIG_fail;
8809     {
8810         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8811         if (SWIG_arg_fail(2)) SWIG_fail;
8812     }
8813     {
8814         arg3 = (bool)(SWIG_As_bool(obj2));
8815         if (SWIG_arg_fail(3)) SWIG_fail;
8816     }
8817     {
8818         PyThreadState* __tstate = wxPyBeginAllowThreads();
8819         (arg1)->SetSashVisible((wxSashEdgePosition )arg2,arg3);
8820
8821         wxPyEndAllowThreads(__tstate);
8822         if (PyErr_Occurred()) SWIG_fail;
8823     }
8824     Py_INCREF(Py_None); resultobj = Py_None;
8825     return resultobj;
8826     fail:
8827     return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_SashWindow_GetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8832     PyObject *resultobj;
8833     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8834     wxSashEdgePosition arg2 ;
8835     bool result;
8836     PyObject * obj0 = 0 ;
8837     PyObject * obj1 = 0 ;
8838     char *kwnames[] = {
8839         (char *) "self",(char *) "edge", NULL
8840     };
8841
8842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetSashVisible",kwnames,&obj0,&obj1)) goto fail;
8843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8844     if (SWIG_arg_fail(1)) SWIG_fail;
8845     {
8846         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8847         if (SWIG_arg_fail(2)) SWIG_fail;
8848     }
8849     {
8850         PyThreadState* __tstate = wxPyBeginAllowThreads();
8851         result = (bool)((wxSashWindow const *)arg1)->GetSashVisible((wxSashEdgePosition )arg2);
8852
8853         wxPyEndAllowThreads(__tstate);
8854         if (PyErr_Occurred()) SWIG_fail;
8855     }
8856     {
8857         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8858     }
8859     return resultobj;
8860     fail:
8861     return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_SashWindow_SetSashBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8866     PyObject *resultobj;
8867     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8868     wxSashEdgePosition arg2 ;
8869     bool arg3 ;
8870     PyObject * obj0 = 0 ;
8871     PyObject * obj1 = 0 ;
8872     PyObject * obj2 = 0 ;
8873     char *kwnames[] = {
8874         (char *) "self",(char *) "edge",(char *) "border", NULL
8875     };
8876
8877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashBorder",kwnames,&obj0,&obj1,&obj2)) goto fail;
8878     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8879     if (SWIG_arg_fail(1)) SWIG_fail;
8880     {
8881         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8882         if (SWIG_arg_fail(2)) SWIG_fail;
8883     }
8884     {
8885         arg3 = (bool)(SWIG_As_bool(obj2));
8886         if (SWIG_arg_fail(3)) SWIG_fail;
8887     }
8888     {
8889         PyThreadState* __tstate = wxPyBeginAllowThreads();
8890         (arg1)->SetSashBorder((wxSashEdgePosition )arg2,arg3);
8891
8892         wxPyEndAllowThreads(__tstate);
8893         if (PyErr_Occurred()) SWIG_fail;
8894     }
8895     Py_INCREF(Py_None); resultobj = Py_None;
8896     return resultobj;
8897     fail:
8898     return NULL;
8899 }
8900
8901
8902 static PyObject *_wrap_SashWindow_HasBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8903     PyObject *resultobj;
8904     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8905     wxSashEdgePosition arg2 ;
8906     bool result;
8907     PyObject * obj0 = 0 ;
8908     PyObject * obj1 = 0 ;
8909     char *kwnames[] = {
8910         (char *) "self",(char *) "edge", NULL
8911     };
8912
8913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_HasBorder",kwnames,&obj0,&obj1)) goto fail;
8914     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8915     if (SWIG_arg_fail(1)) SWIG_fail;
8916     {
8917         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8918         if (SWIG_arg_fail(2)) SWIG_fail;
8919     }
8920     {
8921         PyThreadState* __tstate = wxPyBeginAllowThreads();
8922         result = (bool)((wxSashWindow const *)arg1)->HasBorder((wxSashEdgePosition )arg2);
8923
8924         wxPyEndAllowThreads(__tstate);
8925         if (PyErr_Occurred()) SWIG_fail;
8926     }
8927     {
8928         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8929     }
8930     return resultobj;
8931     fail:
8932     return NULL;
8933 }
8934
8935
8936 static PyObject *_wrap_SashWindow_GetEdgeMargin(PyObject *, PyObject *args, PyObject *kwargs) {
8937     PyObject *resultobj;
8938     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8939     wxSashEdgePosition arg2 ;
8940     int result;
8941     PyObject * obj0 = 0 ;
8942     PyObject * obj1 = 0 ;
8943     char *kwnames[] = {
8944         (char *) "self",(char *) "edge", NULL
8945     };
8946
8947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetEdgeMargin",kwnames,&obj0,&obj1)) goto fail;
8948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8949     if (SWIG_arg_fail(1)) SWIG_fail;
8950     {
8951         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8952         if (SWIG_arg_fail(2)) SWIG_fail;
8953     }
8954     {
8955         PyThreadState* __tstate = wxPyBeginAllowThreads();
8956         result = (int)((wxSashWindow const *)arg1)->GetEdgeMargin((wxSashEdgePosition )arg2);
8957
8958         wxPyEndAllowThreads(__tstate);
8959         if (PyErr_Occurred()) SWIG_fail;
8960     }
8961     {
8962         resultobj = SWIG_From_int((int)(result));
8963     }
8964     return resultobj;
8965     fail:
8966     return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_SashWindow_SetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8971     PyObject *resultobj;
8972     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8973     int arg2 ;
8974     PyObject * obj0 = 0 ;
8975     PyObject * obj1 = 0 ;
8976     char *kwnames[] = {
8977         (char *) "self",(char *) "width", NULL
8978     };
8979
8980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetDefaultBorderSize",kwnames,&obj0,&obj1)) goto fail;
8981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8982     if (SWIG_arg_fail(1)) SWIG_fail;
8983     {
8984         arg2 = (int)(SWIG_As_int(obj1));
8985         if (SWIG_arg_fail(2)) SWIG_fail;
8986     }
8987     {
8988         PyThreadState* __tstate = wxPyBeginAllowThreads();
8989         (arg1)->SetDefaultBorderSize(arg2);
8990
8991         wxPyEndAllowThreads(__tstate);
8992         if (PyErr_Occurred()) SWIG_fail;
8993     }
8994     Py_INCREF(Py_None); resultobj = Py_None;
8995     return resultobj;
8996     fail:
8997     return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_SashWindow_GetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9002     PyObject *resultobj;
9003     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9004     int result;
9005     PyObject * obj0 = 0 ;
9006     char *kwnames[] = {
9007         (char *) "self", NULL
9008     };
9009
9010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetDefaultBorderSize",kwnames,&obj0)) goto fail;
9011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9012     if (SWIG_arg_fail(1)) SWIG_fail;
9013     {
9014         PyThreadState* __tstate = wxPyBeginAllowThreads();
9015         result = (int)((wxSashWindow const *)arg1)->GetDefaultBorderSize();
9016
9017         wxPyEndAllowThreads(__tstate);
9018         if (PyErr_Occurred()) SWIG_fail;
9019     }
9020     {
9021         resultobj = SWIG_From_int((int)(result));
9022     }
9023     return resultobj;
9024     fail:
9025     return NULL;
9026 }
9027
9028
9029 static PyObject *_wrap_SashWindow_SetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9030     PyObject *resultobj;
9031     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9032     int arg2 ;
9033     PyObject * obj0 = 0 ;
9034     PyObject * obj1 = 0 ;
9035     char *kwnames[] = {
9036         (char *) "self",(char *) "width", NULL
9037     };
9038
9039     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetExtraBorderSize",kwnames,&obj0,&obj1)) goto fail;
9040     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9041     if (SWIG_arg_fail(1)) SWIG_fail;
9042     {
9043         arg2 = (int)(SWIG_As_int(obj1));
9044         if (SWIG_arg_fail(2)) SWIG_fail;
9045     }
9046     {
9047         PyThreadState* __tstate = wxPyBeginAllowThreads();
9048         (arg1)->SetExtraBorderSize(arg2);
9049
9050         wxPyEndAllowThreads(__tstate);
9051         if (PyErr_Occurred()) SWIG_fail;
9052     }
9053     Py_INCREF(Py_None); resultobj = Py_None;
9054     return resultobj;
9055     fail:
9056     return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_SashWindow_GetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9061     PyObject *resultobj;
9062     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9063     int result;
9064     PyObject * obj0 = 0 ;
9065     char *kwnames[] = {
9066         (char *) "self", NULL
9067     };
9068
9069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetExtraBorderSize",kwnames,&obj0)) goto fail;
9070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9071     if (SWIG_arg_fail(1)) SWIG_fail;
9072     {
9073         PyThreadState* __tstate = wxPyBeginAllowThreads();
9074         result = (int)((wxSashWindow const *)arg1)->GetExtraBorderSize();
9075
9076         wxPyEndAllowThreads(__tstate);
9077         if (PyErr_Occurred()) SWIG_fail;
9078     }
9079     {
9080         resultobj = SWIG_From_int((int)(result));
9081     }
9082     return resultobj;
9083     fail:
9084     return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_SashWindow_SetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9089     PyObject *resultobj;
9090     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9091     int arg2 ;
9092     PyObject * obj0 = 0 ;
9093     PyObject * obj1 = 0 ;
9094     char *kwnames[] = {
9095         (char *) "self",(char *) "min", NULL
9096     };
9097
9098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeX",kwnames,&obj0,&obj1)) goto fail;
9099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, 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)->SetMinimumSizeX(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_SashWindow_SetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9120     PyObject *resultobj;
9121     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9122     int arg2 ;
9123     PyObject * obj0 = 0 ;
9124     PyObject * obj1 = 0 ;
9125     char *kwnames[] = {
9126         (char *) "self",(char *) "min", NULL
9127     };
9128
9129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeY",kwnames,&obj0,&obj1)) goto fail;
9130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9131     if (SWIG_arg_fail(1)) SWIG_fail;
9132     {
9133         arg2 = (int)(SWIG_As_int(obj1));
9134         if (SWIG_arg_fail(2)) SWIG_fail;
9135     }
9136     {
9137         PyThreadState* __tstate = wxPyBeginAllowThreads();
9138         (arg1)->SetMinimumSizeY(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_SashWindow_GetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9151     PyObject *resultobj;
9152     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9153     int result;
9154     PyObject * obj0 = 0 ;
9155     char *kwnames[] = {
9156         (char *) "self", NULL
9157     };
9158
9159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeX",kwnames,&obj0)) goto fail;
9160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9161     if (SWIG_arg_fail(1)) SWIG_fail;
9162     {
9163         PyThreadState* __tstate = wxPyBeginAllowThreads();
9164         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeX();
9165
9166         wxPyEndAllowThreads(__tstate);
9167         if (PyErr_Occurred()) SWIG_fail;
9168     }
9169     {
9170         resultobj = SWIG_From_int((int)(result));
9171     }
9172     return resultobj;
9173     fail:
9174     return NULL;
9175 }
9176
9177
9178 static PyObject *_wrap_SashWindow_GetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9179     PyObject *resultobj;
9180     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9181     int result;
9182     PyObject * obj0 = 0 ;
9183     char *kwnames[] = {
9184         (char *) "self", NULL
9185     };
9186
9187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeY",kwnames,&obj0)) goto fail;
9188     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9189     if (SWIG_arg_fail(1)) SWIG_fail;
9190     {
9191         PyThreadState* __tstate = wxPyBeginAllowThreads();
9192         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeY();
9193
9194         wxPyEndAllowThreads(__tstate);
9195         if (PyErr_Occurred()) SWIG_fail;
9196     }
9197     {
9198         resultobj = SWIG_From_int((int)(result));
9199     }
9200     return resultobj;
9201     fail:
9202     return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_SashWindow_SetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9207     PyObject *resultobj;
9208     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9209     int arg2 ;
9210     PyObject * obj0 = 0 ;
9211     PyObject * obj1 = 0 ;
9212     char *kwnames[] = {
9213         (char *) "self",(char *) "max", NULL
9214     };
9215
9216     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeX",kwnames,&obj0,&obj1)) goto fail;
9217     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9218     if (SWIG_arg_fail(1)) SWIG_fail;
9219     {
9220         arg2 = (int)(SWIG_As_int(obj1));
9221         if (SWIG_arg_fail(2)) SWIG_fail;
9222     }
9223     {
9224         PyThreadState* __tstate = wxPyBeginAllowThreads();
9225         (arg1)->SetMaximumSizeX(arg2);
9226
9227         wxPyEndAllowThreads(__tstate);
9228         if (PyErr_Occurred()) SWIG_fail;
9229     }
9230     Py_INCREF(Py_None); resultobj = Py_None;
9231     return resultobj;
9232     fail:
9233     return NULL;
9234 }
9235
9236
9237 static PyObject *_wrap_SashWindow_SetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9238     PyObject *resultobj;
9239     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9240     int arg2 ;
9241     PyObject * obj0 = 0 ;
9242     PyObject * obj1 = 0 ;
9243     char *kwnames[] = {
9244         (char *) "self",(char *) "max", NULL
9245     };
9246
9247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeY",kwnames,&obj0,&obj1)) goto fail;
9248     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9249     if (SWIG_arg_fail(1)) SWIG_fail;
9250     {
9251         arg2 = (int)(SWIG_As_int(obj1));
9252         if (SWIG_arg_fail(2)) SWIG_fail;
9253     }
9254     {
9255         PyThreadState* __tstate = wxPyBeginAllowThreads();
9256         (arg1)->SetMaximumSizeY(arg2);
9257
9258         wxPyEndAllowThreads(__tstate);
9259         if (PyErr_Occurred()) SWIG_fail;
9260     }
9261     Py_INCREF(Py_None); resultobj = Py_None;
9262     return resultobj;
9263     fail:
9264     return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_SashWindow_GetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9269     PyObject *resultobj;
9270     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9271     int result;
9272     PyObject * obj0 = 0 ;
9273     char *kwnames[] = {
9274         (char *) "self", NULL
9275     };
9276
9277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeX",kwnames,&obj0)) goto fail;
9278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9279     if (SWIG_arg_fail(1)) SWIG_fail;
9280     {
9281         PyThreadState* __tstate = wxPyBeginAllowThreads();
9282         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeX();
9283
9284         wxPyEndAllowThreads(__tstate);
9285         if (PyErr_Occurred()) SWIG_fail;
9286     }
9287     {
9288         resultobj = SWIG_From_int((int)(result));
9289     }
9290     return resultobj;
9291     fail:
9292     return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_SashWindow_GetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9297     PyObject *resultobj;
9298     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9299     int result;
9300     PyObject * obj0 = 0 ;
9301     char *kwnames[] = {
9302         (char *) "self", NULL
9303     };
9304
9305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeY",kwnames,&obj0)) goto fail;
9306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9307     if (SWIG_arg_fail(1)) SWIG_fail;
9308     {
9309         PyThreadState* __tstate = wxPyBeginAllowThreads();
9310         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeY();
9311
9312         wxPyEndAllowThreads(__tstate);
9313         if (PyErr_Occurred()) SWIG_fail;
9314     }
9315     {
9316         resultobj = SWIG_From_int((int)(result));
9317     }
9318     return resultobj;
9319     fail:
9320     return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_SashWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
9325     PyObject *resultobj;
9326     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9327     int arg2 ;
9328     int arg3 ;
9329     int arg4 = (int) 2 ;
9330     wxSashEdgePosition result;
9331     PyObject * obj0 = 0 ;
9332     PyObject * obj1 = 0 ;
9333     PyObject * obj2 = 0 ;
9334     PyObject * obj3 = 0 ;
9335     char *kwnames[] = {
9336         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
9337     };
9338
9339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SashWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9341     if (SWIG_arg_fail(1)) SWIG_fail;
9342     {
9343         arg2 = (int)(SWIG_As_int(obj1));
9344         if (SWIG_arg_fail(2)) SWIG_fail;
9345     }
9346     {
9347         arg3 = (int)(SWIG_As_int(obj2));
9348         if (SWIG_arg_fail(3)) SWIG_fail;
9349     }
9350     if (obj3) {
9351         {
9352             arg4 = (int)(SWIG_As_int(obj3));
9353             if (SWIG_arg_fail(4)) SWIG_fail;
9354         }
9355     }
9356     {
9357         PyThreadState* __tstate = wxPyBeginAllowThreads();
9358         result = (wxSashEdgePosition)(arg1)->SashHitTest(arg2,arg3,arg4);
9359
9360         wxPyEndAllowThreads(__tstate);
9361         if (PyErr_Occurred()) SWIG_fail;
9362     }
9363     resultobj = SWIG_From_int((result));
9364     return resultobj;
9365     fail:
9366     return NULL;
9367 }
9368
9369
9370 static PyObject *_wrap_SashWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
9371     PyObject *resultobj;
9372     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9373     PyObject * obj0 = 0 ;
9374     char *kwnames[] = {
9375         (char *) "self", NULL
9376     };
9377
9378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_SizeWindows",kwnames,&obj0)) goto fail;
9379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9380     if (SWIG_arg_fail(1)) SWIG_fail;
9381     {
9382         PyThreadState* __tstate = wxPyBeginAllowThreads();
9383         (arg1)->SizeWindows();
9384
9385         wxPyEndAllowThreads(__tstate);
9386         if (PyErr_Occurred()) SWIG_fail;
9387     }
9388     Py_INCREF(Py_None); resultobj = Py_None;
9389     return resultobj;
9390     fail:
9391     return NULL;
9392 }
9393
9394
9395 static PyObject * SashWindow_swigregister(PyObject *, PyObject *args) {
9396     PyObject *obj;
9397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9398     SWIG_TypeClientData(SWIGTYPE_p_wxSashWindow, obj);
9399     Py_INCREF(obj);
9400     return Py_BuildValue((char *)"");
9401 }
9402 static PyObject *_wrap_new_SashEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9403     PyObject *resultobj;
9404     int arg1 = (int) 0 ;
9405     wxSashEdgePosition arg2 = (wxSashEdgePosition) wxSASH_NONE ;
9406     wxSashEvent *result;
9407     PyObject * obj0 = 0 ;
9408     PyObject * obj1 = 0 ;
9409     char *kwnames[] = {
9410         (char *) "id",(char *) "edge", NULL
9411     };
9412
9413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SashEvent",kwnames,&obj0,&obj1)) goto fail;
9414     if (obj0) {
9415         {
9416             arg1 = (int)(SWIG_As_int(obj0));
9417             if (SWIG_arg_fail(1)) SWIG_fail;
9418         }
9419     }
9420     if (obj1) {
9421         {
9422             arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9423             if (SWIG_arg_fail(2)) SWIG_fail;
9424         }
9425     }
9426     {
9427         PyThreadState* __tstate = wxPyBeginAllowThreads();
9428         result = (wxSashEvent *)new wxSashEvent(arg1,(wxSashEdgePosition )arg2);
9429
9430         wxPyEndAllowThreads(__tstate);
9431         if (PyErr_Occurred()) SWIG_fail;
9432     }
9433     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashEvent, 1);
9434     return resultobj;
9435     fail:
9436     return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_SashEvent_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9441     PyObject *resultobj;
9442     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9443     wxSashEdgePosition arg2 ;
9444     PyObject * obj0 = 0 ;
9445     PyObject * obj1 = 0 ;
9446     char *kwnames[] = {
9447         (char *) "self",(char *) "edge", NULL
9448     };
9449
9450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetEdge",kwnames,&obj0,&obj1)) goto fail;
9451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9452     if (SWIG_arg_fail(1)) SWIG_fail;
9453     {
9454         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9455         if (SWIG_arg_fail(2)) SWIG_fail;
9456     }
9457     {
9458         PyThreadState* __tstate = wxPyBeginAllowThreads();
9459         (arg1)->SetEdge((wxSashEdgePosition )arg2);
9460
9461         wxPyEndAllowThreads(__tstate);
9462         if (PyErr_Occurred()) SWIG_fail;
9463     }
9464     Py_INCREF(Py_None); resultobj = Py_None;
9465     return resultobj;
9466     fail:
9467     return NULL;
9468 }
9469
9470
9471 static PyObject *_wrap_SashEvent_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9472     PyObject *resultobj;
9473     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9474     wxSashEdgePosition result;
9475     PyObject * obj0 = 0 ;
9476     char *kwnames[] = {
9477         (char *) "self", NULL
9478     };
9479
9480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetEdge",kwnames,&obj0)) goto fail;
9481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9482     if (SWIG_arg_fail(1)) SWIG_fail;
9483     {
9484         PyThreadState* __tstate = wxPyBeginAllowThreads();
9485         result = (wxSashEdgePosition)((wxSashEvent const *)arg1)->GetEdge();
9486
9487         wxPyEndAllowThreads(__tstate);
9488         if (PyErr_Occurred()) SWIG_fail;
9489     }
9490     resultobj = SWIG_From_int((result));
9491     return resultobj;
9492     fail:
9493     return NULL;
9494 }
9495
9496
9497 static PyObject *_wrap_SashEvent_SetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9498     PyObject *resultobj;
9499     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9500     wxRect *arg2 = 0 ;
9501     wxRect temp2 ;
9502     PyObject * obj0 = 0 ;
9503     PyObject * obj1 = 0 ;
9504     char *kwnames[] = {
9505         (char *) "self",(char *) "rect", NULL
9506     };
9507
9508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragRect",kwnames,&obj0,&obj1)) goto fail;
9509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9510     if (SWIG_arg_fail(1)) SWIG_fail;
9511     {
9512         arg2 = &temp2;
9513         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
9514     }
9515     {
9516         PyThreadState* __tstate = wxPyBeginAllowThreads();
9517         (arg1)->SetDragRect((wxRect const &)*arg2);
9518
9519         wxPyEndAllowThreads(__tstate);
9520         if (PyErr_Occurred()) SWIG_fail;
9521     }
9522     Py_INCREF(Py_None); resultobj = Py_None;
9523     return resultobj;
9524     fail:
9525     return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_SashEvent_GetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9530     PyObject *resultobj;
9531     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9532     wxRect result;
9533     PyObject * obj0 = 0 ;
9534     char *kwnames[] = {
9535         (char *) "self", NULL
9536     };
9537
9538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragRect",kwnames,&obj0)) goto fail;
9539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9540     if (SWIG_arg_fail(1)) SWIG_fail;
9541     {
9542         PyThreadState* __tstate = wxPyBeginAllowThreads();
9543         result = ((wxSashEvent const *)arg1)->GetDragRect();
9544
9545         wxPyEndAllowThreads(__tstate);
9546         if (PyErr_Occurred()) SWIG_fail;
9547     }
9548     {
9549         wxRect * resultptr;
9550         resultptr = new wxRect((wxRect &)(result));
9551         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
9552     }
9553     return resultobj;
9554     fail:
9555     return NULL;
9556 }
9557
9558
9559 static PyObject *_wrap_SashEvent_SetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9560     PyObject *resultobj;
9561     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9562     wxSashDragStatus arg2 ;
9563     PyObject * obj0 = 0 ;
9564     PyObject * obj1 = 0 ;
9565     char *kwnames[] = {
9566         (char *) "self",(char *) "status", NULL
9567     };
9568
9569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragStatus",kwnames,&obj0,&obj1)) goto fail;
9570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9571     if (SWIG_arg_fail(1)) SWIG_fail;
9572     {
9573         arg2 = (wxSashDragStatus)(SWIG_As_int(obj1));
9574         if (SWIG_arg_fail(2)) SWIG_fail;
9575     }
9576     {
9577         PyThreadState* __tstate = wxPyBeginAllowThreads();
9578         (arg1)->SetDragStatus((wxSashDragStatus )arg2);
9579
9580         wxPyEndAllowThreads(__tstate);
9581         if (PyErr_Occurred()) SWIG_fail;
9582     }
9583     Py_INCREF(Py_None); resultobj = Py_None;
9584     return resultobj;
9585     fail:
9586     return NULL;
9587 }
9588
9589
9590 static PyObject *_wrap_SashEvent_GetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9591     PyObject *resultobj;
9592     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9593     wxSashDragStatus result;
9594     PyObject * obj0 = 0 ;
9595     char *kwnames[] = {
9596         (char *) "self", NULL
9597     };
9598
9599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragStatus",kwnames,&obj0)) goto fail;
9600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9601     if (SWIG_arg_fail(1)) SWIG_fail;
9602     {
9603         PyThreadState* __tstate = wxPyBeginAllowThreads();
9604         result = (wxSashDragStatus)((wxSashEvent const *)arg1)->GetDragStatus();
9605
9606         wxPyEndAllowThreads(__tstate);
9607         if (PyErr_Occurred()) SWIG_fail;
9608     }
9609     resultobj = SWIG_From_int((result));
9610     return resultobj;
9611     fail:
9612     return NULL;
9613 }
9614
9615
9616 static PyObject * SashEvent_swigregister(PyObject *, PyObject *args) {
9617     PyObject *obj;
9618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9619     SWIG_TypeClientData(SWIGTYPE_p_wxSashEvent, obj);
9620     Py_INCREF(obj);
9621     return Py_BuildValue((char *)"");
9622 }
9623 static PyObject *_wrap_new_QueryLayoutInfoEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9624     PyObject *resultobj;
9625     int arg1 = (int) 0 ;
9626     wxQueryLayoutInfoEvent *result;
9627     PyObject * obj0 = 0 ;
9628     char *kwnames[] = {
9629         (char *) "id", NULL
9630     };
9631
9632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryLayoutInfoEvent",kwnames,&obj0)) goto fail;
9633     if (obj0) {
9634         {
9635             arg1 = (int)(SWIG_As_int(obj0));
9636             if (SWIG_arg_fail(1)) SWIG_fail;
9637         }
9638     }
9639     {
9640         PyThreadState* __tstate = wxPyBeginAllowThreads();
9641         result = (wxQueryLayoutInfoEvent *)new wxQueryLayoutInfoEvent(arg1);
9642
9643         wxPyEndAllowThreads(__tstate);
9644         if (PyErr_Occurred()) SWIG_fail;
9645     }
9646     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryLayoutInfoEvent, 1);
9647     return resultobj;
9648     fail:
9649     return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_QueryLayoutInfoEvent_SetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9654     PyObject *resultobj;
9655     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9656     int arg2 ;
9657     PyObject * obj0 = 0 ;
9658     PyObject * obj1 = 0 ;
9659     char *kwnames[] = {
9660         (char *) "self",(char *) "length", NULL
9661     };
9662
9663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetRequestedLength",kwnames,&obj0,&obj1)) goto fail;
9664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9665     if (SWIG_arg_fail(1)) SWIG_fail;
9666     {
9667         arg2 = (int)(SWIG_As_int(obj1));
9668         if (SWIG_arg_fail(2)) SWIG_fail;
9669     }
9670     {
9671         PyThreadState* __tstate = wxPyBeginAllowThreads();
9672         (arg1)->SetRequestedLength(arg2);
9673
9674         wxPyEndAllowThreads(__tstate);
9675         if (PyErr_Occurred()) SWIG_fail;
9676     }
9677     Py_INCREF(Py_None); resultobj = Py_None;
9678     return resultobj;
9679     fail:
9680     return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_QueryLayoutInfoEvent_GetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9685     PyObject *resultobj;
9686     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9687     int result;
9688     PyObject * obj0 = 0 ;
9689     char *kwnames[] = {
9690         (char *) "self", NULL
9691     };
9692
9693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetRequestedLength",kwnames,&obj0)) goto fail;
9694     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9695     if (SWIG_arg_fail(1)) SWIG_fail;
9696     {
9697         PyThreadState* __tstate = wxPyBeginAllowThreads();
9698         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetRequestedLength();
9699
9700         wxPyEndAllowThreads(__tstate);
9701         if (PyErr_Occurred()) SWIG_fail;
9702     }
9703     {
9704         resultobj = SWIG_From_int((int)(result));
9705     }
9706     return resultobj;
9707     fail:
9708     return NULL;
9709 }
9710
9711
9712 static PyObject *_wrap_QueryLayoutInfoEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9713     PyObject *resultobj;
9714     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9715     int arg2 ;
9716     PyObject * obj0 = 0 ;
9717     PyObject * obj1 = 0 ;
9718     char *kwnames[] = {
9719         (char *) "self",(char *) "flags", NULL
9720     };
9721
9722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9723     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9724     if (SWIG_arg_fail(1)) SWIG_fail;
9725     {
9726         arg2 = (int)(SWIG_As_int(obj1));
9727         if (SWIG_arg_fail(2)) SWIG_fail;
9728     }
9729     {
9730         PyThreadState* __tstate = wxPyBeginAllowThreads();
9731         (arg1)->SetFlags(arg2);
9732
9733         wxPyEndAllowThreads(__tstate);
9734         if (PyErr_Occurred()) SWIG_fail;
9735     }
9736     Py_INCREF(Py_None); resultobj = Py_None;
9737     return resultobj;
9738     fail:
9739     return NULL;
9740 }
9741
9742
9743 static PyObject *_wrap_QueryLayoutInfoEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9744     PyObject *resultobj;
9745     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9746     int result;
9747     PyObject * obj0 = 0 ;
9748     char *kwnames[] = {
9749         (char *) "self", NULL
9750     };
9751
9752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetFlags",kwnames,&obj0)) goto fail;
9753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9754     if (SWIG_arg_fail(1)) SWIG_fail;
9755     {
9756         PyThreadState* __tstate = wxPyBeginAllowThreads();
9757         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetFlags();
9758
9759         wxPyEndAllowThreads(__tstate);
9760         if (PyErr_Occurred()) SWIG_fail;
9761     }
9762     {
9763         resultobj = SWIG_From_int((int)(result));
9764     }
9765     return resultobj;
9766     fail:
9767     return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_QueryLayoutInfoEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9772     PyObject *resultobj;
9773     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9774     wxSize *arg2 = 0 ;
9775     wxSize temp2 ;
9776     PyObject * obj0 = 0 ;
9777     PyObject * obj1 = 0 ;
9778     char *kwnames[] = {
9779         (char *) "self",(char *) "size", NULL
9780     };
9781
9782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
9783     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9784     if (SWIG_arg_fail(1)) SWIG_fail;
9785     {
9786         arg2 = &temp2;
9787         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9788     }
9789     {
9790         PyThreadState* __tstate = wxPyBeginAllowThreads();
9791         (arg1)->SetSize((wxSize const &)*arg2);
9792
9793         wxPyEndAllowThreads(__tstate);
9794         if (PyErr_Occurred()) SWIG_fail;
9795     }
9796     Py_INCREF(Py_None); resultobj = Py_None;
9797     return resultobj;
9798     fail:
9799     return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_QueryLayoutInfoEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9804     PyObject *resultobj;
9805     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9806     wxSize result;
9807     PyObject * obj0 = 0 ;
9808     char *kwnames[] = {
9809         (char *) "self", NULL
9810     };
9811
9812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetSize",kwnames,&obj0)) goto fail;
9813     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9814     if (SWIG_arg_fail(1)) SWIG_fail;
9815     {
9816         PyThreadState* __tstate = wxPyBeginAllowThreads();
9817         result = ((wxQueryLayoutInfoEvent const *)arg1)->GetSize();
9818
9819         wxPyEndAllowThreads(__tstate);
9820         if (PyErr_Occurred()) SWIG_fail;
9821     }
9822     {
9823         wxSize * resultptr;
9824         resultptr = new wxSize((wxSize &)(result));
9825         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9826     }
9827     return resultobj;
9828     fail:
9829     return NULL;
9830 }
9831
9832
9833 static PyObject *_wrap_QueryLayoutInfoEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9834     PyObject *resultobj;
9835     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9836     wxLayoutOrientation arg2 ;
9837     PyObject * obj0 = 0 ;
9838     PyObject * obj1 = 0 ;
9839     char *kwnames[] = {
9840         (char *) "self",(char *) "orient", NULL
9841     };
9842
9843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
9844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9845     if (SWIG_arg_fail(1)) SWIG_fail;
9846     {
9847         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
9848         if (SWIG_arg_fail(2)) SWIG_fail;
9849     }
9850     {
9851         PyThreadState* __tstate = wxPyBeginAllowThreads();
9852         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
9853
9854         wxPyEndAllowThreads(__tstate);
9855         if (PyErr_Occurred()) SWIG_fail;
9856     }
9857     Py_INCREF(Py_None); resultobj = Py_None;
9858     return resultobj;
9859     fail:
9860     return NULL;
9861 }
9862
9863
9864 static PyObject *_wrap_QueryLayoutInfoEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9865     PyObject *resultobj;
9866     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9867     wxLayoutOrientation result;
9868     PyObject * obj0 = 0 ;
9869     char *kwnames[] = {
9870         (char *) "self", NULL
9871     };
9872
9873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetOrientation",kwnames,&obj0)) goto fail;
9874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9875     if (SWIG_arg_fail(1)) SWIG_fail;
9876     {
9877         PyThreadState* __tstate = wxPyBeginAllowThreads();
9878         result = (wxLayoutOrientation)((wxQueryLayoutInfoEvent const *)arg1)->GetOrientation();
9879
9880         wxPyEndAllowThreads(__tstate);
9881         if (PyErr_Occurred()) SWIG_fail;
9882     }
9883     resultobj = SWIG_From_int((result));
9884     return resultobj;
9885     fail:
9886     return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_QueryLayoutInfoEvent_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9891     PyObject *resultobj;
9892     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9893     wxLayoutAlignment arg2 ;
9894     PyObject * obj0 = 0 ;
9895     PyObject * obj1 = 0 ;
9896     char *kwnames[] = {
9897         (char *) "self",(char *) "align", NULL
9898     };
9899
9900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
9901     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9902     if (SWIG_arg_fail(1)) SWIG_fail;
9903     {
9904         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
9905         if (SWIG_arg_fail(2)) SWIG_fail;
9906     }
9907     {
9908         PyThreadState* __tstate = wxPyBeginAllowThreads();
9909         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
9910
9911         wxPyEndAllowThreads(__tstate);
9912         if (PyErr_Occurred()) SWIG_fail;
9913     }
9914     Py_INCREF(Py_None); resultobj = Py_None;
9915     return resultobj;
9916     fail:
9917     return NULL;
9918 }
9919
9920
9921 static PyObject *_wrap_QueryLayoutInfoEvent_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9922     PyObject *resultobj;
9923     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9924     wxLayoutAlignment result;
9925     PyObject * obj0 = 0 ;
9926     char *kwnames[] = {
9927         (char *) "self", NULL
9928     };
9929
9930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetAlignment",kwnames,&obj0)) goto fail;
9931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9932     if (SWIG_arg_fail(1)) SWIG_fail;
9933     {
9934         PyThreadState* __tstate = wxPyBeginAllowThreads();
9935         result = (wxLayoutAlignment)((wxQueryLayoutInfoEvent const *)arg1)->GetAlignment();
9936
9937         wxPyEndAllowThreads(__tstate);
9938         if (PyErr_Occurred()) SWIG_fail;
9939     }
9940     resultobj = SWIG_From_int((result));
9941     return resultobj;
9942     fail:
9943     return NULL;
9944 }
9945
9946
9947 static PyObject * QueryLayoutInfoEvent_swigregister(PyObject *, PyObject *args) {
9948     PyObject *obj;
9949     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9950     SWIG_TypeClientData(SWIGTYPE_p_wxQueryLayoutInfoEvent, obj);
9951     Py_INCREF(obj);
9952     return Py_BuildValue((char *)"");
9953 }
9954 static PyObject *_wrap_new_CalculateLayoutEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9955     PyObject *resultobj;
9956     int arg1 = (int) 0 ;
9957     wxCalculateLayoutEvent *result;
9958     PyObject * obj0 = 0 ;
9959     char *kwnames[] = {
9960         (char *) "id", NULL
9961     };
9962
9963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CalculateLayoutEvent",kwnames,&obj0)) goto fail;
9964     if (obj0) {
9965         {
9966             arg1 = (int)(SWIG_As_int(obj0));
9967             if (SWIG_arg_fail(1)) SWIG_fail;
9968         }
9969     }
9970     {
9971         PyThreadState* __tstate = wxPyBeginAllowThreads();
9972         result = (wxCalculateLayoutEvent *)new wxCalculateLayoutEvent(arg1);
9973
9974         wxPyEndAllowThreads(__tstate);
9975         if (PyErr_Occurred()) SWIG_fail;
9976     }
9977     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCalculateLayoutEvent, 1);
9978     return resultobj;
9979     fail:
9980     return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_CalculateLayoutEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9985     PyObject *resultobj;
9986     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
9987     int arg2 ;
9988     PyObject * obj0 = 0 ;
9989     PyObject * obj1 = 0 ;
9990     char *kwnames[] = {
9991         (char *) "self",(char *) "flags", NULL
9992     };
9993
9994     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9995     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
9996     if (SWIG_arg_fail(1)) SWIG_fail;
9997     {
9998         arg2 = (int)(SWIG_As_int(obj1));
9999         if (SWIG_arg_fail(2)) SWIG_fail;
10000     }
10001     {
10002         PyThreadState* __tstate = wxPyBeginAllowThreads();
10003         (arg1)->SetFlags(arg2);
10004
10005         wxPyEndAllowThreads(__tstate);
10006         if (PyErr_Occurred()) SWIG_fail;
10007     }
10008     Py_INCREF(Py_None); resultobj = Py_None;
10009     return resultobj;
10010     fail:
10011     return NULL;
10012 }
10013
10014
10015 static PyObject *_wrap_CalculateLayoutEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
10016     PyObject *resultobj;
10017     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10018     int result;
10019     PyObject * obj0 = 0 ;
10020     char *kwnames[] = {
10021         (char *) "self", NULL
10022     };
10023
10024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetFlags",kwnames,&obj0)) goto fail;
10025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10026     if (SWIG_arg_fail(1)) SWIG_fail;
10027     {
10028         PyThreadState* __tstate = wxPyBeginAllowThreads();
10029         result = (int)((wxCalculateLayoutEvent const *)arg1)->GetFlags();
10030
10031         wxPyEndAllowThreads(__tstate);
10032         if (PyErr_Occurred()) SWIG_fail;
10033     }
10034     {
10035         resultobj = SWIG_From_int((int)(result));
10036     }
10037     return resultobj;
10038     fail:
10039     return NULL;
10040 }
10041
10042
10043 static PyObject *_wrap_CalculateLayoutEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10044     PyObject *resultobj;
10045     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10046     wxRect *arg2 = 0 ;
10047     wxRect temp2 ;
10048     PyObject * obj0 = 0 ;
10049     PyObject * obj1 = 0 ;
10050     char *kwnames[] = {
10051         (char *) "self",(char *) "rect", NULL
10052     };
10053
10054     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
10055     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10056     if (SWIG_arg_fail(1)) SWIG_fail;
10057     {
10058         arg2 = &temp2;
10059         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10060     }
10061     {
10062         PyThreadState* __tstate = wxPyBeginAllowThreads();
10063         (arg1)->SetRect((wxRect const &)*arg2);
10064
10065         wxPyEndAllowThreads(__tstate);
10066         if (PyErr_Occurred()) SWIG_fail;
10067     }
10068     Py_INCREF(Py_None); resultobj = Py_None;
10069     return resultobj;
10070     fail:
10071     return NULL;
10072 }
10073
10074
10075 static PyObject *_wrap_CalculateLayoutEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10076     PyObject *resultobj;
10077     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10078     wxRect result;
10079     PyObject * obj0 = 0 ;
10080     char *kwnames[] = {
10081         (char *) "self", NULL
10082     };
10083
10084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetRect",kwnames,&obj0)) goto fail;
10085     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10086     if (SWIG_arg_fail(1)) SWIG_fail;
10087     {
10088         PyThreadState* __tstate = wxPyBeginAllowThreads();
10089         result = ((wxCalculateLayoutEvent const *)arg1)->GetRect();
10090
10091         wxPyEndAllowThreads(__tstate);
10092         if (PyErr_Occurred()) SWIG_fail;
10093     }
10094     {
10095         wxRect * resultptr;
10096         resultptr = new wxRect((wxRect &)(result));
10097         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
10098     }
10099     return resultobj;
10100     fail:
10101     return NULL;
10102 }
10103
10104
10105 static PyObject * CalculateLayoutEvent_swigregister(PyObject *, PyObject *args) {
10106     PyObject *obj;
10107     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10108     SWIG_TypeClientData(SWIGTYPE_p_wxCalculateLayoutEvent, obj);
10109     Py_INCREF(obj);
10110     return Py_BuildValue((char *)"");
10111 }
10112 static PyObject *_wrap_new_SashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10113     PyObject *resultobj;
10114     wxWindow *arg1 = (wxWindow *) 0 ;
10115     int arg2 = (int) -1 ;
10116     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10117     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10118     wxSize const &arg4_defvalue = wxDefaultSize ;
10119     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10120     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10121     wxString const &arg6_defvalue = wxPySashLayoutNameStr ;
10122     wxString *arg6 = (wxString *) &arg6_defvalue ;
10123     wxSashLayoutWindow *result;
10124     wxPoint temp3 ;
10125     wxSize temp4 ;
10126     bool temp6 = false ;
10127     PyObject * obj0 = 0 ;
10128     PyObject * obj1 = 0 ;
10129     PyObject * obj2 = 0 ;
10130     PyObject * obj3 = 0 ;
10131     PyObject * obj4 = 0 ;
10132     PyObject * obj5 = 0 ;
10133     char *kwnames[] = {
10134         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10135     };
10136
10137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashLayoutWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10138     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10139     if (SWIG_arg_fail(1)) SWIG_fail;
10140     if (obj1) {
10141         {
10142             arg2 = (int)(SWIG_As_int(obj1));
10143             if (SWIG_arg_fail(2)) SWIG_fail;
10144         }
10145     }
10146     if (obj2) {
10147         {
10148             arg3 = &temp3;
10149             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10150         }
10151     }
10152     if (obj3) {
10153         {
10154             arg4 = &temp4;
10155             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10156         }
10157     }
10158     if (obj4) {
10159         {
10160             arg5 = (long)(SWIG_As_long(obj4));
10161             if (SWIG_arg_fail(5)) SWIG_fail;
10162         }
10163     }
10164     if (obj5) {
10165         {
10166             arg6 = wxString_in_helper(obj5);
10167             if (arg6 == NULL) SWIG_fail;
10168             temp6 = true;
10169         }
10170     }
10171     {
10172         if (!wxPyCheckForApp()) SWIG_fail;
10173         PyThreadState* __tstate = wxPyBeginAllowThreads();
10174         result = (wxSashLayoutWindow *)new wxSashLayoutWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10175
10176         wxPyEndAllowThreads(__tstate);
10177         if (PyErr_Occurred()) SWIG_fail;
10178     }
10179     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10180     {
10181         if (temp6)
10182         delete arg6;
10183     }
10184     return resultobj;
10185     fail:
10186     {
10187         if (temp6)
10188         delete arg6;
10189     }
10190     return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_new_PreSashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10195     PyObject *resultobj;
10196     wxSashLayoutWindow *result;
10197     char *kwnames[] = {
10198         NULL
10199     };
10200
10201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashLayoutWindow",kwnames)) goto fail;
10202     {
10203         if (!wxPyCheckForApp()) SWIG_fail;
10204         PyThreadState* __tstate = wxPyBeginAllowThreads();
10205         result = (wxSashLayoutWindow *)new wxSashLayoutWindow();
10206
10207         wxPyEndAllowThreads(__tstate);
10208         if (PyErr_Occurred()) SWIG_fail;
10209     }
10210     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10211     return resultobj;
10212     fail:
10213     return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_SashLayoutWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10218     PyObject *resultobj;
10219     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10220     wxWindow *arg2 = (wxWindow *) 0 ;
10221     int arg3 = (int) -1 ;
10222     wxPoint const &arg4_defvalue = wxDefaultPosition ;
10223     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10224     wxSize const &arg5_defvalue = wxDefaultSize ;
10225     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10226     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10227     wxString const &arg7_defvalue = wxPySashLayoutNameStr ;
10228     wxString *arg7 = (wxString *) &arg7_defvalue ;
10229     bool result;
10230     wxPoint temp4 ;
10231     wxSize temp5 ;
10232     bool temp7 = false ;
10233     PyObject * obj0 = 0 ;
10234     PyObject * obj1 = 0 ;
10235     PyObject * obj2 = 0 ;
10236     PyObject * obj3 = 0 ;
10237     PyObject * obj4 = 0 ;
10238     PyObject * obj5 = 0 ;
10239     PyObject * obj6 = 0 ;
10240     char *kwnames[] = {
10241         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10242     };
10243
10244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashLayoutWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10246     if (SWIG_arg_fail(1)) SWIG_fail;
10247     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10248     if (SWIG_arg_fail(2)) SWIG_fail;
10249     if (obj2) {
10250         {
10251             arg3 = (int)(SWIG_As_int(obj2));
10252             if (SWIG_arg_fail(3)) SWIG_fail;
10253         }
10254     }
10255     if (obj3) {
10256         {
10257             arg4 = &temp4;
10258             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10259         }
10260     }
10261     if (obj4) {
10262         {
10263             arg5 = &temp5;
10264             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10265         }
10266     }
10267     if (obj5) {
10268         {
10269             arg6 = (long)(SWIG_As_long(obj5));
10270             if (SWIG_arg_fail(6)) SWIG_fail;
10271         }
10272     }
10273     if (obj6) {
10274         {
10275             arg7 = wxString_in_helper(obj6);
10276             if (arg7 == NULL) SWIG_fail;
10277             temp7 = true;
10278         }
10279     }
10280     {
10281         PyThreadState* __tstate = wxPyBeginAllowThreads();
10282         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10283
10284         wxPyEndAllowThreads(__tstate);
10285         if (PyErr_Occurred()) SWIG_fail;
10286     }
10287     {
10288         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10289     }
10290     {
10291         if (temp7)
10292         delete arg7;
10293     }
10294     return resultobj;
10295     fail:
10296     {
10297         if (temp7)
10298         delete arg7;
10299     }
10300     return NULL;
10301 }
10302
10303
10304 static PyObject *_wrap_SashLayoutWindow_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10305     PyObject *resultobj;
10306     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10307     wxLayoutAlignment result;
10308     PyObject * obj0 = 0 ;
10309     char *kwnames[] = {
10310         (char *) "self", NULL
10311     };
10312
10313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetAlignment",kwnames,&obj0)) goto fail;
10314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10315     if (SWIG_arg_fail(1)) SWIG_fail;
10316     {
10317         PyThreadState* __tstate = wxPyBeginAllowThreads();
10318         result = (wxLayoutAlignment)(arg1)->GetAlignment();
10319
10320         wxPyEndAllowThreads(__tstate);
10321         if (PyErr_Occurred()) SWIG_fail;
10322     }
10323     resultobj = SWIG_From_int((result));
10324     return resultobj;
10325     fail:
10326     return NULL;
10327 }
10328
10329
10330 static PyObject *_wrap_SashLayoutWindow_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10331     PyObject *resultobj;
10332     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10333     wxLayoutOrientation result;
10334     PyObject * obj0 = 0 ;
10335     char *kwnames[] = {
10336         (char *) "self", NULL
10337     };
10338
10339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetOrientation",kwnames,&obj0)) goto fail;
10340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10341     if (SWIG_arg_fail(1)) SWIG_fail;
10342     {
10343         PyThreadState* __tstate = wxPyBeginAllowThreads();
10344         result = (wxLayoutOrientation)(arg1)->GetOrientation();
10345
10346         wxPyEndAllowThreads(__tstate);
10347         if (PyErr_Occurred()) SWIG_fail;
10348     }
10349     resultobj = SWIG_From_int((result));
10350     return resultobj;
10351     fail:
10352     return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_SashLayoutWindow_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10357     PyObject *resultobj;
10358     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10359     wxLayoutAlignment arg2 ;
10360     PyObject * obj0 = 0 ;
10361     PyObject * obj1 = 0 ;
10362     char *kwnames[] = {
10363         (char *) "self",(char *) "alignment", NULL
10364     };
10365
10366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
10367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10368     if (SWIG_arg_fail(1)) SWIG_fail;
10369     {
10370         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
10371         if (SWIG_arg_fail(2)) SWIG_fail;
10372     }
10373     {
10374         PyThreadState* __tstate = wxPyBeginAllowThreads();
10375         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
10376
10377         wxPyEndAllowThreads(__tstate);
10378         if (PyErr_Occurred()) SWIG_fail;
10379     }
10380     Py_INCREF(Py_None); resultobj = Py_None;
10381     return resultobj;
10382     fail:
10383     return NULL;
10384 }
10385
10386
10387 static PyObject *_wrap_SashLayoutWindow_SetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
10388     PyObject *resultobj;
10389     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10390     wxSize *arg2 = 0 ;
10391     wxSize temp2 ;
10392     PyObject * obj0 = 0 ;
10393     PyObject * obj1 = 0 ;
10394     char *kwnames[] = {
10395         (char *) "self",(char *) "size", NULL
10396     };
10397
10398     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetDefaultSize",kwnames,&obj0,&obj1)) goto fail;
10399     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10400     if (SWIG_arg_fail(1)) SWIG_fail;
10401     {
10402         arg2 = &temp2;
10403         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10404     }
10405     {
10406         PyThreadState* __tstate = wxPyBeginAllowThreads();
10407         (arg1)->SetDefaultSize((wxSize const &)*arg2);
10408
10409         wxPyEndAllowThreads(__tstate);
10410         if (PyErr_Occurred()) SWIG_fail;
10411     }
10412     Py_INCREF(Py_None); resultobj = Py_None;
10413     return resultobj;
10414     fail:
10415     return NULL;
10416 }
10417
10418
10419 static PyObject *_wrap_SashLayoutWindow_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10420     PyObject *resultobj;
10421     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10422     wxLayoutOrientation arg2 ;
10423     PyObject * obj0 = 0 ;
10424     PyObject * obj1 = 0 ;
10425     char *kwnames[] = {
10426         (char *) "self",(char *) "orientation", NULL
10427     };
10428
10429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
10430     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10431     if (SWIG_arg_fail(1)) SWIG_fail;
10432     {
10433         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
10434         if (SWIG_arg_fail(2)) SWIG_fail;
10435     }
10436     {
10437         PyThreadState* __tstate = wxPyBeginAllowThreads();
10438         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
10439
10440         wxPyEndAllowThreads(__tstate);
10441         if (PyErr_Occurred()) SWIG_fail;
10442     }
10443     Py_INCREF(Py_None); resultobj = Py_None;
10444     return resultobj;
10445     fail:
10446     return NULL;
10447 }
10448
10449
10450 static PyObject * SashLayoutWindow_swigregister(PyObject *, PyObject *args) {
10451     PyObject *obj;
10452     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10453     SWIG_TypeClientData(SWIGTYPE_p_wxSashLayoutWindow, obj);
10454     Py_INCREF(obj);
10455     return Py_BuildValue((char *)"");
10456 }
10457 static PyObject *_wrap_new_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10458     PyObject *resultobj;
10459     wxLayoutAlgorithm *result;
10460     char *kwnames[] = {
10461         NULL
10462     };
10463
10464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutAlgorithm",kwnames)) goto fail;
10465     {
10466         PyThreadState* __tstate = wxPyBeginAllowThreads();
10467         result = (wxLayoutAlgorithm *)new wxLayoutAlgorithm();
10468
10469         wxPyEndAllowThreads(__tstate);
10470         if (PyErr_Occurred()) SWIG_fail;
10471     }
10472     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutAlgorithm, 1);
10473     return resultobj;
10474     fail:
10475     return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_delete_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10480     PyObject *resultobj;
10481     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10482     PyObject * obj0 = 0 ;
10483     char *kwnames[] = {
10484         (char *) "self", NULL
10485     };
10486
10487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LayoutAlgorithm",kwnames,&obj0)) goto fail;
10488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10489     if (SWIG_arg_fail(1)) SWIG_fail;
10490     {
10491         PyThreadState* __tstate = wxPyBeginAllowThreads();
10492         delete arg1;
10493
10494         wxPyEndAllowThreads(__tstate);
10495         if (PyErr_Occurred()) SWIG_fail;
10496     }
10497     Py_INCREF(Py_None); resultobj = Py_None;
10498     return resultobj;
10499     fail:
10500     return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_LayoutAlgorithm_LayoutMDIFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10505     PyObject *resultobj;
10506     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10507     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
10508     wxRect *arg3 = (wxRect *) NULL ;
10509     bool result;
10510     PyObject * obj0 = 0 ;
10511     PyObject * obj1 = 0 ;
10512     PyObject * obj2 = 0 ;
10513     char *kwnames[] = {
10514         (char *) "self",(char *) "frame",(char *) "rect", NULL
10515     };
10516
10517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutMDIFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10519     if (SWIG_arg_fail(1)) SWIG_fail;
10520     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
10521     if (SWIG_arg_fail(2)) SWIG_fail;
10522     if (obj2) {
10523         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10524         if (SWIG_arg_fail(3)) SWIG_fail;
10525     }
10526     {
10527         PyThreadState* __tstate = wxPyBeginAllowThreads();
10528         result = (bool)(arg1)->LayoutMDIFrame(arg2,arg3);
10529
10530         wxPyEndAllowThreads(__tstate);
10531         if (PyErr_Occurred()) SWIG_fail;
10532     }
10533     {
10534         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10535     }
10536     return resultobj;
10537     fail:
10538     return NULL;
10539 }
10540
10541
10542 static PyObject *_wrap_LayoutAlgorithm_LayoutFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10543     PyObject *resultobj;
10544     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10545     wxFrame *arg2 = (wxFrame *) 0 ;
10546     wxWindow *arg3 = (wxWindow *) NULL ;
10547     bool result;
10548     PyObject * obj0 = 0 ;
10549     PyObject * obj1 = 0 ;
10550     PyObject * obj2 = 0 ;
10551     char *kwnames[] = {
10552         (char *) "self",(char *) "frame",(char *) "mainWindow", NULL
10553     };
10554
10555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10557     if (SWIG_arg_fail(1)) SWIG_fail;
10558     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10559     if (SWIG_arg_fail(2)) SWIG_fail;
10560     if (obj2) {
10561         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10562         if (SWIG_arg_fail(3)) SWIG_fail;
10563     }
10564     {
10565         PyThreadState* __tstate = wxPyBeginAllowThreads();
10566         result = (bool)(arg1)->LayoutFrame(arg2,arg3);
10567
10568         wxPyEndAllowThreads(__tstate);
10569         if (PyErr_Occurred()) SWIG_fail;
10570     }
10571     {
10572         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10573     }
10574     return resultobj;
10575     fail:
10576     return NULL;
10577 }
10578
10579
10580 static PyObject *_wrap_LayoutAlgorithm_LayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10581     PyObject *resultobj;
10582     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10583     wxWindow *arg2 = (wxWindow *) 0 ;
10584     wxWindow *arg3 = (wxWindow *) NULL ;
10585     bool result;
10586     PyObject * obj0 = 0 ;
10587     PyObject * obj1 = 0 ;
10588     PyObject * obj2 = 0 ;
10589     char *kwnames[] = {
10590         (char *) "self",(char *) "parent",(char *) "mainWindow", NULL
10591     };
10592
10593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
10594     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10595     if (SWIG_arg_fail(1)) SWIG_fail;
10596     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10597     if (SWIG_arg_fail(2)) SWIG_fail;
10598     if (obj2) {
10599         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10600         if (SWIG_arg_fail(3)) SWIG_fail;
10601     }
10602     {
10603         PyThreadState* __tstate = wxPyBeginAllowThreads();
10604         result = (bool)(arg1)->LayoutWindow(arg2,arg3);
10605
10606         wxPyEndAllowThreads(__tstate);
10607         if (PyErr_Occurred()) SWIG_fail;
10608     }
10609     {
10610         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10611     }
10612     return resultobj;
10613     fail:
10614     return NULL;
10615 }
10616
10617
10618 static PyObject * LayoutAlgorithm_swigregister(PyObject *, PyObject *args) {
10619     PyObject *obj;
10620     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10621     SWIG_TypeClientData(SWIGTYPE_p_wxLayoutAlgorithm, obj);
10622     Py_INCREF(obj);
10623     return Py_BuildValue((char *)"");
10624 }
10625 static PyObject *_wrap_new_PopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10626     PyObject *resultobj;
10627     wxWindow *arg1 = (wxWindow *) 0 ;
10628     int arg2 = (int) wxBORDER_NONE ;
10629     wxPopupWindow *result;
10630     PyObject * obj0 = 0 ;
10631     PyObject * obj1 = 0 ;
10632     char *kwnames[] = {
10633         (char *) "parent",(char *) "flags", NULL
10634     };
10635
10636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupWindow",kwnames,&obj0,&obj1)) goto fail;
10637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10638     if (SWIG_arg_fail(1)) SWIG_fail;
10639     if (obj1) {
10640         {
10641             arg2 = (int)(SWIG_As_int(obj1));
10642             if (SWIG_arg_fail(2)) SWIG_fail;
10643         }
10644     }
10645     {
10646         if (!wxPyCheckForApp()) SWIG_fail;
10647         PyThreadState* __tstate = wxPyBeginAllowThreads();
10648         result = (wxPopupWindow *)new wxPopupWindow(arg1,arg2);
10649
10650         wxPyEndAllowThreads(__tstate);
10651         if (PyErr_Occurred()) SWIG_fail;
10652     }
10653     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10654     return resultobj;
10655     fail:
10656     return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_new_PrePopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10661     PyObject *resultobj;
10662     wxPopupWindow *result;
10663     char *kwnames[] = {
10664         NULL
10665     };
10666
10667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupWindow",kwnames)) goto fail;
10668     {
10669         if (!wxPyCheckForApp()) SWIG_fail;
10670         PyThreadState* __tstate = wxPyBeginAllowThreads();
10671         result = (wxPopupWindow *)new wxPopupWindow();
10672
10673         wxPyEndAllowThreads(__tstate);
10674         if (PyErr_Occurred()) SWIG_fail;
10675     }
10676     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10677     return resultobj;
10678     fail:
10679     return NULL;
10680 }
10681
10682
10683 static PyObject *_wrap_PopupWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10684     PyObject *resultobj;
10685     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10686     wxWindow *arg2 = (wxWindow *) 0 ;
10687     int arg3 = (int) wxBORDER_NONE ;
10688     bool result;
10689     PyObject * obj0 = 0 ;
10690     PyObject * obj1 = 0 ;
10691     PyObject * obj2 = 0 ;
10692     char *kwnames[] = {
10693         (char *) "self",(char *) "parent",(char *) "flags", NULL
10694     };
10695
10696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PopupWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10698     if (SWIG_arg_fail(1)) SWIG_fail;
10699     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10700     if (SWIG_arg_fail(2)) SWIG_fail;
10701     if (obj2) {
10702         {
10703             arg3 = (int)(SWIG_As_int(obj2));
10704             if (SWIG_arg_fail(3)) SWIG_fail;
10705         }
10706     }
10707     {
10708         PyThreadState* __tstate = wxPyBeginAllowThreads();
10709         result = (bool)(arg1)->Create(arg2,arg3);
10710
10711         wxPyEndAllowThreads(__tstate);
10712         if (PyErr_Occurred()) SWIG_fail;
10713     }
10714     {
10715         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10716     }
10717     return resultobj;
10718     fail:
10719     return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_PopupWindow_Position(PyObject *, PyObject *args, PyObject *kwargs) {
10724     PyObject *resultobj;
10725     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10726     wxPoint *arg2 = 0 ;
10727     wxSize *arg3 = 0 ;
10728     wxPoint temp2 ;
10729     wxSize temp3 ;
10730     PyObject * obj0 = 0 ;
10731     PyObject * obj1 = 0 ;
10732     PyObject * obj2 = 0 ;
10733     char *kwnames[] = {
10734         (char *) "self",(char *) "ptOrigin",(char *) "size", NULL
10735     };
10736
10737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupWindow_Position",kwnames,&obj0,&obj1,&obj2)) goto fail;
10738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10739     if (SWIG_arg_fail(1)) SWIG_fail;
10740     {
10741         arg2 = &temp2;
10742         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10743     }
10744     {
10745         arg3 = &temp3;
10746         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
10747     }
10748     {
10749         PyThreadState* __tstate = wxPyBeginAllowThreads();
10750         (arg1)->Position((wxPoint const &)*arg2,(wxSize const &)*arg3);
10751
10752         wxPyEndAllowThreads(__tstate);
10753         if (PyErr_Occurred()) SWIG_fail;
10754     }
10755     Py_INCREF(Py_None); resultobj = Py_None;
10756     return resultobj;
10757     fail:
10758     return NULL;
10759 }
10760
10761
10762 static PyObject * PopupWindow_swigregister(PyObject *, PyObject *args) {
10763     PyObject *obj;
10764     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10765     SWIG_TypeClientData(SWIGTYPE_p_wxPopupWindow, obj);
10766     Py_INCREF(obj);
10767     return Py_BuildValue((char *)"");
10768 }
10769 static PyObject *_wrap_new_PopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10770     PyObject *resultobj;
10771     wxWindow *arg1 = (wxWindow *) 0 ;
10772     int arg2 = (int) wxBORDER_NONE ;
10773     wxPyPopupTransientWindow *result;
10774     PyObject * obj0 = 0 ;
10775     PyObject * obj1 = 0 ;
10776     char *kwnames[] = {
10777         (char *) "parent",(char *) "style", NULL
10778     };
10779
10780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupTransientWindow",kwnames,&obj0,&obj1)) goto fail;
10781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10782     if (SWIG_arg_fail(1)) SWIG_fail;
10783     if (obj1) {
10784         {
10785             arg2 = (int)(SWIG_As_int(obj1));
10786             if (SWIG_arg_fail(2)) SWIG_fail;
10787         }
10788     }
10789     {
10790         if (!wxPyCheckForApp()) SWIG_fail;
10791         PyThreadState* __tstate = wxPyBeginAllowThreads();
10792         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow(arg1,arg2);
10793
10794         wxPyEndAllowThreads(__tstate);
10795         if (PyErr_Occurred()) SWIG_fail;
10796     }
10797     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10798     return resultobj;
10799     fail:
10800     return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_new_PrePopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10805     PyObject *resultobj;
10806     wxPyPopupTransientWindow *result;
10807     char *kwnames[] = {
10808         NULL
10809     };
10810
10811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupTransientWindow",kwnames)) goto fail;
10812     {
10813         if (!wxPyCheckForApp()) SWIG_fail;
10814         PyThreadState* __tstate = wxPyBeginAllowThreads();
10815         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow();
10816
10817         wxPyEndAllowThreads(__tstate);
10818         if (PyErr_Occurred()) SWIG_fail;
10819     }
10820     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10821     return resultobj;
10822     fail:
10823     return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_PopupTransientWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10828     PyObject *resultobj;
10829     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10830     PyObject *arg2 = (PyObject *) 0 ;
10831     PyObject *arg3 = (PyObject *) 0 ;
10832     PyObject * obj0 = 0 ;
10833     PyObject * obj1 = 0 ;
10834     PyObject * obj2 = 0 ;
10835     char *kwnames[] = {
10836         (char *) "self",(char *) "self",(char *) "_class", NULL
10837     };
10838
10839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupTransientWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10841     if (SWIG_arg_fail(1)) SWIG_fail;
10842     arg2 = obj1;
10843     arg3 = obj2;
10844     {
10845         PyThreadState* __tstate = wxPyBeginAllowThreads();
10846         (arg1)->_setCallbackInfo(arg2,arg3);
10847
10848         wxPyEndAllowThreads(__tstate);
10849         if (PyErr_Occurred()) SWIG_fail;
10850     }
10851     Py_INCREF(Py_None); resultobj = Py_None;
10852     return resultobj;
10853     fail:
10854     return NULL;
10855 }
10856
10857
10858 static PyObject *_wrap_PopupTransientWindow_Popup(PyObject *, PyObject *args, PyObject *kwargs) {
10859     PyObject *resultobj;
10860     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10861     wxWindow *arg2 = (wxWindow *) NULL ;
10862     PyObject * obj0 = 0 ;
10863     PyObject * obj1 = 0 ;
10864     char *kwnames[] = {
10865         (char *) "self",(char *) "focus", NULL
10866     };
10867
10868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PopupTransientWindow_Popup",kwnames,&obj0,&obj1)) goto fail;
10869     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10870     if (SWIG_arg_fail(1)) SWIG_fail;
10871     if (obj1) {
10872         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10873         if (SWIG_arg_fail(2)) SWIG_fail;
10874     }
10875     {
10876         PyThreadState* __tstate = wxPyBeginAllowThreads();
10877         (arg1)->Popup(arg2);
10878
10879         wxPyEndAllowThreads(__tstate);
10880         if (PyErr_Occurred()) SWIG_fail;
10881     }
10882     Py_INCREF(Py_None); resultobj = Py_None;
10883     return resultobj;
10884     fail:
10885     return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_PopupTransientWindow_Dismiss(PyObject *, PyObject *args, PyObject *kwargs) {
10890     PyObject *resultobj;
10891     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10892     PyObject * obj0 = 0 ;
10893     char *kwnames[] = {
10894         (char *) "self", NULL
10895     };
10896
10897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PopupTransientWindow_Dismiss",kwnames,&obj0)) goto fail;
10898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10899     if (SWIG_arg_fail(1)) SWIG_fail;
10900     {
10901         PyThreadState* __tstate = wxPyBeginAllowThreads();
10902         (arg1)->Dismiss();
10903
10904         wxPyEndAllowThreads(__tstate);
10905         if (PyErr_Occurred()) SWIG_fail;
10906     }
10907     Py_INCREF(Py_None); resultobj = Py_None;
10908     return resultobj;
10909     fail:
10910     return NULL;
10911 }
10912
10913
10914 static PyObject * PopupTransientWindow_swigregister(PyObject *, PyObject *args) {
10915     PyObject *obj;
10916     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10917     SWIG_TypeClientData(SWIGTYPE_p_wxPyPopupTransientWindow, obj);
10918     Py_INCREF(obj);
10919     return Py_BuildValue((char *)"");
10920 }
10921 static PyObject *_wrap_new_TipWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10922     PyObject *resultobj;
10923     wxWindow *arg1 = (wxWindow *) 0 ;
10924     wxString *arg2 = 0 ;
10925     int arg3 = (int) 100 ;
10926     wxRect *arg4 = (wxRect *) NULL ;
10927     wxTipWindow *result;
10928     bool temp2 = false ;
10929     PyObject * obj0 = 0 ;
10930     PyObject * obj1 = 0 ;
10931     PyObject * obj2 = 0 ;
10932     PyObject * obj3 = 0 ;
10933     char *kwnames[] = {
10934         (char *) "parent",(char *) "text",(char *) "maxLength",(char *) "rectBound", NULL
10935     };
10936
10937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_TipWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10939     if (SWIG_arg_fail(1)) SWIG_fail;
10940     {
10941         arg2 = wxString_in_helper(obj1);
10942         if (arg2 == NULL) SWIG_fail;
10943         temp2 = true;
10944     }
10945     if (obj2) {
10946         {
10947             arg3 = (int)(SWIG_As_int(obj2));
10948             if (SWIG_arg_fail(3)) SWIG_fail;
10949         }
10950     }
10951     if (obj3) {
10952         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10953         if (SWIG_arg_fail(4)) SWIG_fail;
10954     }
10955     {
10956         if (!wxPyCheckForApp()) SWIG_fail;
10957         PyThreadState* __tstate = wxPyBeginAllowThreads();
10958         result = (wxTipWindow *)new_wxTipWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10959
10960         wxPyEndAllowThreads(__tstate);
10961         if (PyErr_Occurred()) SWIG_fail;
10962     }
10963     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipWindow, 1);
10964     {
10965         if (temp2)
10966         delete arg2;
10967     }
10968     return resultobj;
10969     fail:
10970     {
10971         if (temp2)
10972         delete arg2;
10973     }
10974     return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_TipWindow_SetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
10979     PyObject *resultobj;
10980     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10981     wxRect *arg2 = 0 ;
10982     wxRect temp2 ;
10983     PyObject * obj0 = 0 ;
10984     PyObject * obj1 = 0 ;
10985     char *kwnames[] = {
10986         (char *) "self",(char *) "rectBound", NULL
10987     };
10988
10989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipWindow_SetBoundingRect",kwnames,&obj0,&obj1)) goto fail;
10990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10991     if (SWIG_arg_fail(1)) SWIG_fail;
10992     {
10993         arg2 = &temp2;
10994         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10995     }
10996     {
10997         PyThreadState* __tstate = wxPyBeginAllowThreads();
10998         (arg1)->SetBoundingRect((wxRect const &)*arg2);
10999
11000         wxPyEndAllowThreads(__tstate);
11001         if (PyErr_Occurred()) SWIG_fail;
11002     }
11003     Py_INCREF(Py_None); resultobj = Py_None;
11004     return resultobj;
11005     fail:
11006     return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_TipWindow_Close(PyObject *, PyObject *args, PyObject *kwargs) {
11011     PyObject *resultobj;
11012     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
11013     PyObject * obj0 = 0 ;
11014     char *kwnames[] = {
11015         (char *) "self", NULL
11016     };
11017
11018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipWindow_Close",kwnames,&obj0)) goto fail;
11019     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
11020     if (SWIG_arg_fail(1)) SWIG_fail;
11021     {
11022         PyThreadState* __tstate = wxPyBeginAllowThreads();
11023         (arg1)->Close();
11024
11025         wxPyEndAllowThreads(__tstate);
11026         if (PyErr_Occurred()) SWIG_fail;
11027     }
11028     Py_INCREF(Py_None); resultobj = Py_None;
11029     return resultobj;
11030     fail:
11031     return NULL;
11032 }
11033
11034
11035 static PyObject * TipWindow_swigregister(PyObject *, PyObject *args) {
11036     PyObject *obj;
11037     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11038     SWIG_TypeClientData(SWIGTYPE_p_wxTipWindow, obj);
11039     Py_INCREF(obj);
11040     return Py_BuildValue((char *)"");
11041 }
11042 static PyObject *_wrap_new_VScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
11043     PyObject *resultobj;
11044     wxWindow *arg1 = (wxWindow *) 0 ;
11045     int arg2 = (int) wxID_ANY ;
11046     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11047     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11048     wxSize const &arg4_defvalue = wxDefaultSize ;
11049     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11050     long arg5 = (long) 0 ;
11051     wxString const &arg6_defvalue = wxPyPanelNameStr ;
11052     wxString *arg6 = (wxString *) &arg6_defvalue ;
11053     wxPyVScrolledWindow *result;
11054     wxPoint temp3 ;
11055     wxSize temp4 ;
11056     bool temp6 = false ;
11057     PyObject * obj0 = 0 ;
11058     PyObject * obj1 = 0 ;
11059     PyObject * obj2 = 0 ;
11060     PyObject * obj3 = 0 ;
11061     PyObject * obj4 = 0 ;
11062     PyObject * obj5 = 0 ;
11063     char *kwnames[] = {
11064         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11065     };
11066
11067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11069     if (SWIG_arg_fail(1)) SWIG_fail;
11070     if (obj1) {
11071         {
11072             arg2 = (int)(SWIG_As_int(obj1));
11073             if (SWIG_arg_fail(2)) SWIG_fail;
11074         }
11075     }
11076     if (obj2) {
11077         {
11078             arg3 = &temp3;
11079             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11080         }
11081     }
11082     if (obj3) {
11083         {
11084             arg4 = &temp4;
11085             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11086         }
11087     }
11088     if (obj4) {
11089         {
11090             arg5 = (long)(SWIG_As_long(obj4));
11091             if (SWIG_arg_fail(5)) SWIG_fail;
11092         }
11093     }
11094     if (obj5) {
11095         {
11096             arg6 = wxString_in_helper(obj5);
11097             if (arg6 == NULL) SWIG_fail;
11098             temp6 = true;
11099         }
11100     }
11101     {
11102         if (!wxPyCheckForApp()) SWIG_fail;
11103         PyThreadState* __tstate = wxPyBeginAllowThreads();
11104         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11105
11106         wxPyEndAllowThreads(__tstate);
11107         if (PyErr_Occurred()) SWIG_fail;
11108     }
11109     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11110     {
11111         if (temp6)
11112         delete arg6;
11113     }
11114     return resultobj;
11115     fail:
11116     {
11117         if (temp6)
11118         delete arg6;
11119     }
11120     return NULL;
11121 }
11122
11123
11124 static PyObject *_wrap_new_PreVScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
11125     PyObject *resultobj;
11126     wxPyVScrolledWindow *result;
11127     char *kwnames[] = {
11128         NULL
11129     };
11130
11131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVScrolledWindow",kwnames)) goto fail;
11132     {
11133         if (!wxPyCheckForApp()) SWIG_fail;
11134         PyThreadState* __tstate = wxPyBeginAllowThreads();
11135         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow();
11136
11137         wxPyEndAllowThreads(__tstate);
11138         if (PyErr_Occurred()) SWIG_fail;
11139     }
11140     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11141     return resultobj;
11142     fail:
11143     return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_VScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11148     PyObject *resultobj;
11149     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11150     PyObject *arg2 = (PyObject *) 0 ;
11151     PyObject *arg3 = (PyObject *) 0 ;
11152     PyObject * obj0 = 0 ;
11153     PyObject * obj1 = 0 ;
11154     PyObject * obj2 = 0 ;
11155     char *kwnames[] = {
11156         (char *) "self",(char *) "self",(char *) "_class", NULL
11157     };
11158
11159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11161     if (SWIG_arg_fail(1)) SWIG_fail;
11162     arg2 = obj1;
11163     arg3 = obj2;
11164     {
11165         PyThreadState* __tstate = wxPyBeginAllowThreads();
11166         (arg1)->_setCallbackInfo(arg2,arg3);
11167
11168         wxPyEndAllowThreads(__tstate);
11169         if (PyErr_Occurred()) SWIG_fail;
11170     }
11171     Py_INCREF(Py_None); resultobj = Py_None;
11172     return resultobj;
11173     fail:
11174     return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_VScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11179     PyObject *resultobj;
11180     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11181     wxWindow *arg2 = (wxWindow *) 0 ;
11182     int arg3 = (int) wxID_ANY ;
11183     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11184     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11185     wxSize const &arg5_defvalue = wxDefaultSize ;
11186     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11187     long arg6 = (long) 0 ;
11188     wxString const &arg7_defvalue = wxPyPanelNameStr ;
11189     wxString *arg7 = (wxString *) &arg7_defvalue ;
11190     bool result;
11191     wxPoint temp4 ;
11192     wxSize temp5 ;
11193     bool temp7 = false ;
11194     PyObject * obj0 = 0 ;
11195     PyObject * obj1 = 0 ;
11196     PyObject * obj2 = 0 ;
11197     PyObject * obj3 = 0 ;
11198     PyObject * obj4 = 0 ;
11199     PyObject * obj5 = 0 ;
11200     PyObject * obj6 = 0 ;
11201     char *kwnames[] = {
11202         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11203     };
11204
11205     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11206     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11207     if (SWIG_arg_fail(1)) SWIG_fail;
11208     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11209     if (SWIG_arg_fail(2)) SWIG_fail;
11210     if (obj2) {
11211         {
11212             arg3 = (int)(SWIG_As_int(obj2));
11213             if (SWIG_arg_fail(3)) SWIG_fail;
11214         }
11215     }
11216     if (obj3) {
11217         {
11218             arg4 = &temp4;
11219             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11220         }
11221     }
11222     if (obj4) {
11223         {
11224             arg5 = &temp5;
11225             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11226         }
11227     }
11228     if (obj5) {
11229         {
11230             arg6 = (long)(SWIG_As_long(obj5));
11231             if (SWIG_arg_fail(6)) SWIG_fail;
11232         }
11233     }
11234     if (obj6) {
11235         {
11236             arg7 = wxString_in_helper(obj6);
11237             if (arg7 == NULL) SWIG_fail;
11238             temp7 = true;
11239         }
11240     }
11241     {
11242         PyThreadState* __tstate = wxPyBeginAllowThreads();
11243         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11244
11245         wxPyEndAllowThreads(__tstate);
11246         if (PyErr_Occurred()) SWIG_fail;
11247     }
11248     {
11249         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11250     }
11251     {
11252         if (temp7)
11253         delete arg7;
11254     }
11255     return resultobj;
11256     fail:
11257     {
11258         if (temp7)
11259         delete arg7;
11260     }
11261     return NULL;
11262 }
11263
11264
11265 static PyObject *_wrap_VScrolledWindow_SetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11266     PyObject *resultobj;
11267     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11268     size_t arg2 ;
11269     PyObject * obj0 = 0 ;
11270     PyObject * obj1 = 0 ;
11271     char *kwnames[] = {
11272         (char *) "self",(char *) "count", NULL
11273     };
11274
11275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_SetLineCount",kwnames,&obj0,&obj1)) goto fail;
11276     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11277     if (SWIG_arg_fail(1)) SWIG_fail;
11278     {
11279         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11280         if (SWIG_arg_fail(2)) SWIG_fail;
11281     }
11282     {
11283         PyThreadState* __tstate = wxPyBeginAllowThreads();
11284         (arg1)->SetLineCount(arg2);
11285
11286         wxPyEndAllowThreads(__tstate);
11287         if (PyErr_Occurred()) SWIG_fail;
11288     }
11289     Py_INCREF(Py_None); resultobj = Py_None;
11290     return resultobj;
11291     fail:
11292     return NULL;
11293 }
11294
11295
11296 static PyObject *_wrap_VScrolledWindow_ScrollToLine(PyObject *, PyObject *args, PyObject *kwargs) {
11297     PyObject *resultobj;
11298     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11299     size_t arg2 ;
11300     bool result;
11301     PyObject * obj0 = 0 ;
11302     PyObject * obj1 = 0 ;
11303     char *kwnames[] = {
11304         (char *) "self",(char *) "line", NULL
11305     };
11306
11307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollToLine",kwnames,&obj0,&obj1)) goto fail;
11308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11309     if (SWIG_arg_fail(1)) SWIG_fail;
11310     {
11311         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11312         if (SWIG_arg_fail(2)) SWIG_fail;
11313     }
11314     {
11315         PyThreadState* __tstate = wxPyBeginAllowThreads();
11316         result = (bool)(arg1)->ScrollToLine(arg2);
11317
11318         wxPyEndAllowThreads(__tstate);
11319         if (PyErr_Occurred()) SWIG_fail;
11320     }
11321     {
11322         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11323     }
11324     return resultobj;
11325     fail:
11326     return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_VScrolledWindow_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
11331     PyObject *resultobj;
11332     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11333     int arg2 ;
11334     bool result;
11335     PyObject * obj0 = 0 ;
11336     PyObject * obj1 = 0 ;
11337     char *kwnames[] = {
11338         (char *) "self",(char *) "lines", NULL
11339     };
11340
11341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
11342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11343     if (SWIG_arg_fail(1)) SWIG_fail;
11344     {
11345         arg2 = (int)(SWIG_As_int(obj1));
11346         if (SWIG_arg_fail(2)) SWIG_fail;
11347     }
11348     {
11349         PyThreadState* __tstate = wxPyBeginAllowThreads();
11350         result = (bool)(arg1)->ScrollLines(arg2);
11351
11352         wxPyEndAllowThreads(__tstate);
11353         if (PyErr_Occurred()) SWIG_fail;
11354     }
11355     {
11356         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11357     }
11358     return resultobj;
11359     fail:
11360     return NULL;
11361 }
11362
11363
11364 static PyObject *_wrap_VScrolledWindow_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
11365     PyObject *resultobj;
11366     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11367     int arg2 ;
11368     bool result;
11369     PyObject * obj0 = 0 ;
11370     PyObject * obj1 = 0 ;
11371     char *kwnames[] = {
11372         (char *) "self",(char *) "pages", NULL
11373     };
11374
11375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
11376     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11377     if (SWIG_arg_fail(1)) SWIG_fail;
11378     {
11379         arg2 = (int)(SWIG_As_int(obj1));
11380         if (SWIG_arg_fail(2)) SWIG_fail;
11381     }
11382     {
11383         PyThreadState* __tstate = wxPyBeginAllowThreads();
11384         result = (bool)(arg1)->ScrollPages(arg2);
11385
11386         wxPyEndAllowThreads(__tstate);
11387         if (PyErr_Occurred()) SWIG_fail;
11388     }
11389     {
11390         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11391     }
11392     return resultobj;
11393     fail:
11394     return NULL;
11395 }
11396
11397
11398 static PyObject *_wrap_VScrolledWindow_RefreshLine(PyObject *, PyObject *args, PyObject *kwargs) {
11399     PyObject *resultobj;
11400     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11401     size_t arg2 ;
11402     PyObject * obj0 = 0 ;
11403     PyObject * obj1 = 0 ;
11404     char *kwnames[] = {
11405         (char *) "self",(char *) "line", NULL
11406     };
11407
11408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_RefreshLine",kwnames,&obj0,&obj1)) goto fail;
11409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11410     if (SWIG_arg_fail(1)) SWIG_fail;
11411     {
11412         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11413         if (SWIG_arg_fail(2)) SWIG_fail;
11414     }
11415     {
11416         PyThreadState* __tstate = wxPyBeginAllowThreads();
11417         (arg1)->RefreshLine(arg2);
11418
11419         wxPyEndAllowThreads(__tstate);
11420         if (PyErr_Occurred()) SWIG_fail;
11421     }
11422     Py_INCREF(Py_None); resultobj = Py_None;
11423     return resultobj;
11424     fail:
11425     return NULL;
11426 }
11427
11428
11429 static PyObject *_wrap_VScrolledWindow_RefreshLines(PyObject *, PyObject *args, PyObject *kwargs) {
11430     PyObject *resultobj;
11431     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11432     size_t arg2 ;
11433     size_t arg3 ;
11434     PyObject * obj0 = 0 ;
11435     PyObject * obj1 = 0 ;
11436     PyObject * obj2 = 0 ;
11437     char *kwnames[] = {
11438         (char *) "self",(char *) "from",(char *) "to", NULL
11439     };
11440
11441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_RefreshLines",kwnames,&obj0,&obj1,&obj2)) goto fail;
11442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11443     if (SWIG_arg_fail(1)) SWIG_fail;
11444     {
11445         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11446         if (SWIG_arg_fail(2)) SWIG_fail;
11447     }
11448     {
11449         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11450         if (SWIG_arg_fail(3)) SWIG_fail;
11451     }
11452     {
11453         PyThreadState* __tstate = wxPyBeginAllowThreads();
11454         (arg1)->RefreshLines(arg2,arg3);
11455
11456         wxPyEndAllowThreads(__tstate);
11457         if (PyErr_Occurred()) SWIG_fail;
11458     }
11459     Py_INCREF(Py_None); resultobj = Py_None;
11460     return resultobj;
11461     fail:
11462     return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_VScrolledWindow_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
11467     PyObject *resultobj;
11468     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11469     int arg2 ;
11470     int arg3 ;
11471     int result;
11472     PyObject * obj0 = 0 ;
11473     PyObject * obj1 = 0 ;
11474     PyObject * obj2 = 0 ;
11475     char *kwnames[] = {
11476         (char *) "self",(char *) "x",(char *) "y", NULL
11477     };
11478
11479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
11480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11481     if (SWIG_arg_fail(1)) SWIG_fail;
11482     {
11483         arg2 = (int)(SWIG_As_int(obj1));
11484         if (SWIG_arg_fail(2)) SWIG_fail;
11485     }
11486     {
11487         arg3 = (int)(SWIG_As_int(obj2));
11488         if (SWIG_arg_fail(3)) SWIG_fail;
11489     }
11490     {
11491         PyThreadState* __tstate = wxPyBeginAllowThreads();
11492         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest(arg2,arg3);
11493
11494         wxPyEndAllowThreads(__tstate);
11495         if (PyErr_Occurred()) SWIG_fail;
11496     }
11497     {
11498         resultobj = SWIG_From_int((int)(result));
11499     }
11500     return resultobj;
11501     fail:
11502     return NULL;
11503 }
11504
11505
11506 static PyObject *_wrap_VScrolledWindow_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11507     PyObject *resultobj;
11508     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11509     wxPoint *arg2 = 0 ;
11510     int result;
11511     wxPoint temp2 ;
11512     PyObject * obj0 = 0 ;
11513     PyObject * obj1 = 0 ;
11514     char *kwnames[] = {
11515         (char *) "self",(char *) "pt", NULL
11516     };
11517
11518     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_HitTest",kwnames,&obj0,&obj1)) goto fail;
11519     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11520     if (SWIG_arg_fail(1)) SWIG_fail;
11521     {
11522         arg2 = &temp2;
11523         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11524     }
11525     {
11526         PyThreadState* __tstate = wxPyBeginAllowThreads();
11527         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
11528
11529         wxPyEndAllowThreads(__tstate);
11530         if (PyErr_Occurred()) SWIG_fail;
11531     }
11532     {
11533         resultobj = SWIG_From_int((int)(result));
11534     }
11535     return resultobj;
11536     fail:
11537     return NULL;
11538 }
11539
11540
11541 static PyObject *_wrap_VScrolledWindow_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
11542     PyObject *resultobj;
11543     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11544     PyObject * obj0 = 0 ;
11545     char *kwnames[] = {
11546         (char *) "self", NULL
11547     };
11548
11549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_RefreshAll",kwnames,&obj0)) goto fail;
11550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11551     if (SWIG_arg_fail(1)) SWIG_fail;
11552     {
11553         PyThreadState* __tstate = wxPyBeginAllowThreads();
11554         (arg1)->RefreshAll();
11555
11556         wxPyEndAllowThreads(__tstate);
11557         if (PyErr_Occurred()) SWIG_fail;
11558     }
11559     Py_INCREF(Py_None); resultobj = Py_None;
11560     return resultobj;
11561     fail:
11562     return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_VScrolledWindow_GetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11567     PyObject *resultobj;
11568     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11569     size_t result;
11570     PyObject * obj0 = 0 ;
11571     char *kwnames[] = {
11572         (char *) "self", NULL
11573     };
11574
11575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLineCount",kwnames,&obj0)) goto fail;
11576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11577     if (SWIG_arg_fail(1)) SWIG_fail;
11578     {
11579         PyThreadState* __tstate = wxPyBeginAllowThreads();
11580         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLineCount();
11581
11582         wxPyEndAllowThreads(__tstate);
11583         if (PyErr_Occurred()) SWIG_fail;
11584     }
11585     {
11586         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11587     }
11588     return resultobj;
11589     fail:
11590     return NULL;
11591 }
11592
11593
11594 static PyObject *_wrap_VScrolledWindow_GetFirstVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11595     PyObject *resultobj;
11596     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11597     size_t result;
11598     PyObject * obj0 = 0 ;
11599     char *kwnames[] = {
11600         (char *) "self", NULL
11601     };
11602
11603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetFirstVisibleLine",kwnames,&obj0)) goto fail;
11604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11605     if (SWIG_arg_fail(1)) SWIG_fail;
11606     {
11607         PyThreadState* __tstate = wxPyBeginAllowThreads();
11608         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetFirstVisibleLine();
11609
11610         wxPyEndAllowThreads(__tstate);
11611         if (PyErr_Occurred()) SWIG_fail;
11612     }
11613     {
11614         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11615     }
11616     return resultobj;
11617     fail:
11618     return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_VScrolledWindow_GetLastVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11623     PyObject *resultobj;
11624     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11625     size_t result;
11626     PyObject * obj0 = 0 ;
11627     char *kwnames[] = {
11628         (char *) "self", NULL
11629     };
11630
11631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLastVisibleLine",kwnames,&obj0)) goto fail;
11632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11633     if (SWIG_arg_fail(1)) SWIG_fail;
11634     {
11635         PyThreadState* __tstate = wxPyBeginAllowThreads();
11636         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLastVisibleLine();
11637
11638         wxPyEndAllowThreads(__tstate);
11639         if (PyErr_Occurred()) SWIG_fail;
11640     }
11641     {
11642         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11643     }
11644     return resultobj;
11645     fail:
11646     return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_VScrolledWindow_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11651     PyObject *resultobj;
11652     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11653     size_t arg2 ;
11654     bool result;
11655     PyObject * obj0 = 0 ;
11656     PyObject * obj1 = 0 ;
11657     char *kwnames[] = {
11658         (char *) "self",(char *) "line", NULL
11659     };
11660
11661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_IsVisible",kwnames,&obj0,&obj1)) goto fail;
11662     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11663     if (SWIG_arg_fail(1)) SWIG_fail;
11664     {
11665         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11666         if (SWIG_arg_fail(2)) SWIG_fail;
11667     }
11668     {
11669         PyThreadState* __tstate = wxPyBeginAllowThreads();
11670         result = (bool)((wxPyVScrolledWindow const *)arg1)->IsVisible(arg2);
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 * VScrolledWindow_swigregister(PyObject *, PyObject *args) {
11685     PyObject *obj;
11686     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11687     SWIG_TypeClientData(SWIGTYPE_p_wxPyVScrolledWindow, obj);
11688     Py_INCREF(obj);
11689     return Py_BuildValue((char *)"");
11690 }
11691 static int _wrap_VListBoxNameStr_set(PyObject *) {
11692     PyErr_SetString(PyExc_TypeError,"Variable VListBoxNameStr is read-only.");
11693     return 1;
11694 }
11695
11696
11697 static PyObject *_wrap_VListBoxNameStr_get(void) {
11698     PyObject *pyobj;
11699
11700     {
11701 #if wxUSE_UNICODE
11702         pyobj = PyUnicode_FromWideChar((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11703 #else
11704         pyobj = PyString_FromStringAndSize((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11705 #endif
11706     }
11707     return pyobj;
11708 }
11709
11710
11711 static PyObject *_wrap_new_VListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11712     PyObject *resultobj;
11713     wxWindow *arg1 = (wxWindow *) 0 ;
11714     int arg2 = (int) wxID_ANY ;
11715     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11716     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11717     wxSize const &arg4_defvalue = wxDefaultSize ;
11718     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11719     long arg5 = (long) 0 ;
11720     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
11721     wxString *arg6 = (wxString *) &arg6_defvalue ;
11722     wxPyVListBox *result;
11723     wxPoint temp3 ;
11724     wxSize temp4 ;
11725     bool temp6 = false ;
11726     PyObject * obj0 = 0 ;
11727     PyObject * obj1 = 0 ;
11728     PyObject * obj2 = 0 ;
11729     PyObject * obj3 = 0 ;
11730     PyObject * obj4 = 0 ;
11731     PyObject * obj5 = 0 ;
11732     char *kwnames[] = {
11733         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11734     };
11735
11736     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11737     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11738     if (SWIG_arg_fail(1)) SWIG_fail;
11739     if (obj1) {
11740         {
11741             arg2 = (int)(SWIG_As_int(obj1));
11742             if (SWIG_arg_fail(2)) SWIG_fail;
11743         }
11744     }
11745     if (obj2) {
11746         {
11747             arg3 = &temp3;
11748             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11749         }
11750     }
11751     if (obj3) {
11752         {
11753             arg4 = &temp4;
11754             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11755         }
11756     }
11757     if (obj4) {
11758         {
11759             arg5 = (long)(SWIG_As_long(obj4));
11760             if (SWIG_arg_fail(5)) SWIG_fail;
11761         }
11762     }
11763     if (obj5) {
11764         {
11765             arg6 = wxString_in_helper(obj5);
11766             if (arg6 == NULL) SWIG_fail;
11767             temp6 = true;
11768         }
11769     }
11770     {
11771         if (!wxPyCheckForApp()) SWIG_fail;
11772         PyThreadState* __tstate = wxPyBeginAllowThreads();
11773         result = (wxPyVListBox *)new wxPyVListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11774
11775         wxPyEndAllowThreads(__tstate);
11776         if (PyErr_Occurred()) SWIG_fail;
11777     }
11778     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11779     {
11780         if (temp6)
11781         delete arg6;
11782     }
11783     return resultobj;
11784     fail:
11785     {
11786         if (temp6)
11787         delete arg6;
11788     }
11789     return NULL;
11790 }
11791
11792
11793 static PyObject *_wrap_new_PreVListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11794     PyObject *resultobj;
11795     wxPyVListBox *result;
11796     char *kwnames[] = {
11797         NULL
11798     };
11799
11800     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVListBox",kwnames)) goto fail;
11801     {
11802         if (!wxPyCheckForApp()) SWIG_fail;
11803         PyThreadState* __tstate = wxPyBeginAllowThreads();
11804         result = (wxPyVListBox *)new wxPyVListBox();
11805
11806         wxPyEndAllowThreads(__tstate);
11807         if (PyErr_Occurred()) SWIG_fail;
11808     }
11809     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11810     return resultobj;
11811     fail:
11812     return NULL;
11813 }
11814
11815
11816 static PyObject *_wrap_VListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11817     PyObject *resultobj;
11818     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11819     PyObject *arg2 = (PyObject *) 0 ;
11820     PyObject *arg3 = (PyObject *) 0 ;
11821     PyObject * obj0 = 0 ;
11822     PyObject * obj1 = 0 ;
11823     PyObject * obj2 = 0 ;
11824     char *kwnames[] = {
11825         (char *) "self",(char *) "self",(char *) "_class", NULL
11826     };
11827
11828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11829     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11830     if (SWIG_arg_fail(1)) SWIG_fail;
11831     arg2 = obj1;
11832     arg3 = obj2;
11833     {
11834         PyThreadState* __tstate = wxPyBeginAllowThreads();
11835         (arg1)->_setCallbackInfo(arg2,arg3);
11836
11837         wxPyEndAllowThreads(__tstate);
11838         if (PyErr_Occurred()) SWIG_fail;
11839     }
11840     Py_INCREF(Py_None); resultobj = Py_None;
11841     return resultobj;
11842     fail:
11843     return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_VListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11848     PyObject *resultobj;
11849     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11850     wxWindow *arg2 = (wxWindow *) 0 ;
11851     int arg3 = (int) wxID_ANY ;
11852     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11853     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11854     wxSize const &arg5_defvalue = wxDefaultSize ;
11855     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11856     long arg6 = (long) 0 ;
11857     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
11858     wxString *arg7 = (wxString *) &arg7_defvalue ;
11859     bool result;
11860     wxPoint temp4 ;
11861     wxSize temp5 ;
11862     bool temp7 = false ;
11863     PyObject * obj0 = 0 ;
11864     PyObject * obj1 = 0 ;
11865     PyObject * obj2 = 0 ;
11866     PyObject * obj3 = 0 ;
11867     PyObject * obj4 = 0 ;
11868     PyObject * obj5 = 0 ;
11869     PyObject * obj6 = 0 ;
11870     char *kwnames[] = {
11871         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11872     };
11873
11874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11875     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11876     if (SWIG_arg_fail(1)) SWIG_fail;
11877     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11878     if (SWIG_arg_fail(2)) SWIG_fail;
11879     if (obj2) {
11880         {
11881             arg3 = (int)(SWIG_As_int(obj2));
11882             if (SWIG_arg_fail(3)) SWIG_fail;
11883         }
11884     }
11885     if (obj3) {
11886         {
11887             arg4 = &temp4;
11888             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11889         }
11890     }
11891     if (obj4) {
11892         {
11893             arg5 = &temp5;
11894             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11895         }
11896     }
11897     if (obj5) {
11898         {
11899             arg6 = (long)(SWIG_As_long(obj5));
11900             if (SWIG_arg_fail(6)) SWIG_fail;
11901         }
11902     }
11903     if (obj6) {
11904         {
11905             arg7 = wxString_in_helper(obj6);
11906             if (arg7 == NULL) SWIG_fail;
11907             temp7 = true;
11908         }
11909     }
11910     {
11911         PyThreadState* __tstate = wxPyBeginAllowThreads();
11912         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11913
11914         wxPyEndAllowThreads(__tstate);
11915         if (PyErr_Occurred()) SWIG_fail;
11916     }
11917     {
11918         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11919     }
11920     {
11921         if (temp7)
11922         delete arg7;
11923     }
11924     return resultobj;
11925     fail:
11926     {
11927         if (temp7)
11928         delete arg7;
11929     }
11930     return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_VListBox_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
11935     PyObject *resultobj;
11936     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11937     size_t result;
11938     PyObject * obj0 = 0 ;
11939     char *kwnames[] = {
11940         (char *) "self", NULL
11941     };
11942
11943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetItemCount",kwnames,&obj0)) goto fail;
11944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11945     if (SWIG_arg_fail(1)) SWIG_fail;
11946     {
11947         PyThreadState* __tstate = wxPyBeginAllowThreads();
11948         result = (size_t)((wxPyVListBox const *)arg1)->GetItemCount();
11949
11950         wxPyEndAllowThreads(__tstate);
11951         if (PyErr_Occurred()) SWIG_fail;
11952     }
11953     {
11954         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11955     }
11956     return resultobj;
11957     fail:
11958     return NULL;
11959 }
11960
11961
11962 static PyObject *_wrap_VListBox_HasMultipleSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11963     PyObject *resultobj;
11964     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11965     bool result;
11966     PyObject * obj0 = 0 ;
11967     char *kwnames[] = {
11968         (char *) "self", NULL
11969     };
11970
11971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_HasMultipleSelection",kwnames,&obj0)) goto fail;
11972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11973     if (SWIG_arg_fail(1)) SWIG_fail;
11974     {
11975         PyThreadState* __tstate = wxPyBeginAllowThreads();
11976         result = (bool)((wxPyVListBox const *)arg1)->HasMultipleSelection();
11977
11978         wxPyEndAllowThreads(__tstate);
11979         if (PyErr_Occurred()) SWIG_fail;
11980     }
11981     {
11982         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11983     }
11984     return resultobj;
11985     fail:
11986     return NULL;
11987 }
11988
11989
11990 static PyObject *_wrap_VListBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11991     PyObject *resultobj;
11992     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11993     int result;
11994     PyObject * obj0 = 0 ;
11995     char *kwnames[] = {
11996         (char *) "self", NULL
11997     };
11998
11999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelection",kwnames,&obj0)) goto fail;
12000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12001     if (SWIG_arg_fail(1)) SWIG_fail;
12002     {
12003         PyThreadState* __tstate = wxPyBeginAllowThreads();
12004         result = (int)((wxPyVListBox const *)arg1)->GetSelection();
12005
12006         wxPyEndAllowThreads(__tstate);
12007         if (PyErr_Occurred()) SWIG_fail;
12008     }
12009     {
12010         resultobj = SWIG_From_int((int)(result));
12011     }
12012     return resultobj;
12013     fail:
12014     return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_VListBox_IsCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
12019     PyObject *resultobj;
12020     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12021     size_t arg2 ;
12022     bool result;
12023     PyObject * obj0 = 0 ;
12024     PyObject * obj1 = 0 ;
12025     char *kwnames[] = {
12026         (char *) "self",(char *) "item", NULL
12027     };
12028
12029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsCurrent",kwnames,&obj0,&obj1)) goto fail;
12030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12031     if (SWIG_arg_fail(1)) SWIG_fail;
12032     {
12033         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12034         if (SWIG_arg_fail(2)) SWIG_fail;
12035     }
12036     {
12037         PyThreadState* __tstate = wxPyBeginAllowThreads();
12038         result = (bool)((wxPyVListBox const *)arg1)->IsCurrent(arg2);
12039
12040         wxPyEndAllowThreads(__tstate);
12041         if (PyErr_Occurred()) SWIG_fail;
12042     }
12043     {
12044         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12045     }
12046     return resultobj;
12047     fail:
12048     return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_VListBox_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12053     PyObject *resultobj;
12054     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12055     size_t arg2 ;
12056     bool result;
12057     PyObject * obj0 = 0 ;
12058     PyObject * obj1 = 0 ;
12059     char *kwnames[] = {
12060         (char *) "self",(char *) "item", NULL
12061     };
12062
12063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
12064     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12065     if (SWIG_arg_fail(1)) SWIG_fail;
12066     {
12067         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12068         if (SWIG_arg_fail(2)) SWIG_fail;
12069     }
12070     {
12071         PyThreadState* __tstate = wxPyBeginAllowThreads();
12072         result = (bool)((wxPyVListBox const *)arg1)->IsSelected(arg2);
12073
12074         wxPyEndAllowThreads(__tstate);
12075         if (PyErr_Occurred()) SWIG_fail;
12076     }
12077     {
12078         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12079     }
12080     return resultobj;
12081     fail:
12082     return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_VListBox_GetSelectedCount(PyObject *, PyObject *args, PyObject *kwargs) {
12087     PyObject *resultobj;
12088     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12089     size_t result;
12090     PyObject * obj0 = 0 ;
12091     char *kwnames[] = {
12092         (char *) "self", NULL
12093     };
12094
12095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectedCount",kwnames,&obj0)) goto fail;
12096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12097     if (SWIG_arg_fail(1)) SWIG_fail;
12098     {
12099         PyThreadState* __tstate = wxPyBeginAllowThreads();
12100         result = (size_t)((wxPyVListBox const *)arg1)->GetSelectedCount();
12101
12102         wxPyEndAllowThreads(__tstate);
12103         if (PyErr_Occurred()) SWIG_fail;
12104     }
12105     {
12106         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
12107     }
12108     return resultobj;
12109     fail:
12110     return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_VListBox_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12115     PyObject *resultobj;
12116     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12117     PyObject *result;
12118     PyObject * obj0 = 0 ;
12119     char *kwnames[] = {
12120         (char *) "self", NULL
12121     };
12122
12123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetFirstSelected",kwnames,&obj0)) goto fail;
12124     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12125     if (SWIG_arg_fail(1)) SWIG_fail;
12126     {
12127         PyThreadState* __tstate = wxPyBeginAllowThreads();
12128         result = (PyObject *)wxPyVListBox_GetFirstSelected(arg1);
12129
12130         wxPyEndAllowThreads(__tstate);
12131         if (PyErr_Occurred()) SWIG_fail;
12132     }
12133     resultobj = result;
12134     return resultobj;
12135     fail:
12136     return NULL;
12137 }
12138
12139
12140 static PyObject *_wrap_VListBox_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12141     PyObject *resultobj;
12142     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12143     unsigned long arg2 ;
12144     PyObject *result;
12145     PyObject * obj0 = 0 ;
12146     PyObject * obj1 = 0 ;
12147     char *kwnames[] = {
12148         (char *) "self",(char *) "cookie", NULL
12149     };
12150
12151     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
12152     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12153     if (SWIG_arg_fail(1)) SWIG_fail;
12154     {
12155         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
12156         if (SWIG_arg_fail(2)) SWIG_fail;
12157     }
12158     {
12159         PyThreadState* __tstate = wxPyBeginAllowThreads();
12160         result = (PyObject *)wxPyVListBox_GetNextSelected(arg1,arg2);
12161
12162         wxPyEndAllowThreads(__tstate);
12163         if (PyErr_Occurred()) SWIG_fail;
12164     }
12165     resultobj = result;
12166     return resultobj;
12167     fail:
12168     return NULL;
12169 }
12170
12171
12172 static PyObject *_wrap_VListBox_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12173     PyObject *resultobj;
12174     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12175     wxPoint result;
12176     PyObject * obj0 = 0 ;
12177     char *kwnames[] = {
12178         (char *) "self", NULL
12179     };
12180
12181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetMargins",kwnames,&obj0)) goto fail;
12182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12183     if (SWIG_arg_fail(1)) SWIG_fail;
12184     {
12185         PyThreadState* __tstate = wxPyBeginAllowThreads();
12186         result = ((wxPyVListBox const *)arg1)->GetMargins();
12187
12188         wxPyEndAllowThreads(__tstate);
12189         if (PyErr_Occurred()) SWIG_fail;
12190     }
12191     {
12192         wxPoint * resultptr;
12193         resultptr = new wxPoint((wxPoint &)(result));
12194         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12195     }
12196     return resultobj;
12197     fail:
12198     return NULL;
12199 }
12200
12201
12202 static PyObject *_wrap_VListBox_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12203     PyObject *resultobj;
12204     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12205     wxColour *result;
12206     PyObject * obj0 = 0 ;
12207     char *kwnames[] = {
12208         (char *) "self", NULL
12209     };
12210
12211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectionBackground",kwnames,&obj0)) goto fail;
12212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12213     if (SWIG_arg_fail(1)) SWIG_fail;
12214     {
12215         PyThreadState* __tstate = wxPyBeginAllowThreads();
12216         {
12217             wxColour const &_result_ref = ((wxPyVListBox const *)arg1)->GetSelectionBackground();
12218             result = (wxColour *) &_result_ref;
12219         }
12220
12221         wxPyEndAllowThreads(__tstate);
12222         if (PyErr_Occurred()) SWIG_fail;
12223     }
12224     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
12225     return resultobj;
12226     fail:
12227     return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_VListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12232     PyObject *resultobj;
12233     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12234     size_t arg2 ;
12235     PyObject * obj0 = 0 ;
12236     PyObject * obj1 = 0 ;
12237     char *kwnames[] = {
12238         (char *) "self",(char *) "count", NULL
12239     };
12240
12241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12243     if (SWIG_arg_fail(1)) SWIG_fail;
12244     {
12245         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12246         if (SWIG_arg_fail(2)) SWIG_fail;
12247     }
12248     {
12249         PyThreadState* __tstate = wxPyBeginAllowThreads();
12250         (arg1)->SetItemCount(arg2);
12251
12252         wxPyEndAllowThreads(__tstate);
12253         if (PyErr_Occurred()) SWIG_fail;
12254     }
12255     Py_INCREF(Py_None); resultobj = Py_None;
12256     return resultobj;
12257     fail:
12258     return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_VListBox_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
12263     PyObject *resultobj;
12264     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12265     PyObject * obj0 = 0 ;
12266     char *kwnames[] = {
12267         (char *) "self", NULL
12268     };
12269
12270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_Clear",kwnames,&obj0)) goto fail;
12271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12272     if (SWIG_arg_fail(1)) SWIG_fail;
12273     {
12274         PyThreadState* __tstate = wxPyBeginAllowThreads();
12275         (arg1)->Clear();
12276
12277         wxPyEndAllowThreads(__tstate);
12278         if (PyErr_Occurred()) SWIG_fail;
12279     }
12280     Py_INCREF(Py_None); resultobj = Py_None;
12281     return resultobj;
12282     fail:
12283     return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_VListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
12288     PyObject *resultobj;
12289     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12290     int arg2 ;
12291     PyObject * obj0 = 0 ;
12292     PyObject * obj1 = 0 ;
12293     char *kwnames[] = {
12294         (char *) "self",(char *) "selection", NULL
12295     };
12296
12297     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
12298     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12299     if (SWIG_arg_fail(1)) SWIG_fail;
12300     {
12301         arg2 = (int)(SWIG_As_int(obj1));
12302         if (SWIG_arg_fail(2)) SWIG_fail;
12303     }
12304     {
12305         PyThreadState* __tstate = wxPyBeginAllowThreads();
12306         (arg1)->SetSelection(arg2);
12307
12308         wxPyEndAllowThreads(__tstate);
12309         if (PyErr_Occurred()) SWIG_fail;
12310     }
12311     Py_INCREF(Py_None); resultobj = Py_None;
12312     return resultobj;
12313     fail:
12314     return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_VListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
12319     PyObject *resultobj;
12320     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12321     size_t arg2 ;
12322     bool arg3 = (bool) true ;
12323     bool result;
12324     PyObject * obj0 = 0 ;
12325     PyObject * obj1 = 0 ;
12326     PyObject * obj2 = 0 ;
12327     char *kwnames[] = {
12328         (char *) "self",(char *) "item",(char *) "select", NULL
12329     };
12330
12331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:VListBox_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
12332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12333     if (SWIG_arg_fail(1)) SWIG_fail;
12334     {
12335         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12336         if (SWIG_arg_fail(2)) SWIG_fail;
12337     }
12338     if (obj2) {
12339         {
12340             arg3 = (bool)(SWIG_As_bool(obj2));
12341             if (SWIG_arg_fail(3)) SWIG_fail;
12342         }
12343     }
12344     {
12345         PyThreadState* __tstate = wxPyBeginAllowThreads();
12346         result = (bool)(arg1)->Select(arg2,arg3);
12347
12348         wxPyEndAllowThreads(__tstate);
12349         if (PyErr_Occurred()) SWIG_fail;
12350     }
12351     {
12352         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12353     }
12354     return resultobj;
12355     fail:
12356     return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_VListBox_SelectRange(PyObject *, PyObject *args, PyObject *kwargs) {
12361     PyObject *resultobj;
12362     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12363     size_t arg2 ;
12364     size_t arg3 ;
12365     bool result;
12366     PyObject * obj0 = 0 ;
12367     PyObject * obj1 = 0 ;
12368     PyObject * obj2 = 0 ;
12369     char *kwnames[] = {
12370         (char *) "self",(char *) "from",(char *) "to", NULL
12371     };
12372
12373     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SelectRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12374     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12375     if (SWIG_arg_fail(1)) SWIG_fail;
12376     {
12377         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12378         if (SWIG_arg_fail(2)) SWIG_fail;
12379     }
12380     {
12381         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12382         if (SWIG_arg_fail(3)) SWIG_fail;
12383     }
12384     {
12385         PyThreadState* __tstate = wxPyBeginAllowThreads();
12386         result = (bool)(arg1)->SelectRange(arg2,arg3);
12387
12388         wxPyEndAllowThreads(__tstate);
12389         if (PyErr_Occurred()) SWIG_fail;
12390     }
12391     {
12392         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12393     }
12394     return resultobj;
12395     fail:
12396     return NULL;
12397 }
12398
12399
12400 static PyObject *_wrap_VListBox_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
12401     PyObject *resultobj;
12402     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12403     size_t arg2 ;
12404     PyObject * obj0 = 0 ;
12405     PyObject * obj1 = 0 ;
12406     char *kwnames[] = {
12407         (char *) "self",(char *) "item", NULL
12408     };
12409
12410     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_Toggle",kwnames,&obj0,&obj1)) goto fail;
12411     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12412     if (SWIG_arg_fail(1)) SWIG_fail;
12413     {
12414         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12415         if (SWIG_arg_fail(2)) SWIG_fail;
12416     }
12417     {
12418         PyThreadState* __tstate = wxPyBeginAllowThreads();
12419         (arg1)->Toggle(arg2);
12420
12421         wxPyEndAllowThreads(__tstate);
12422         if (PyErr_Occurred()) SWIG_fail;
12423     }
12424     Py_INCREF(Py_None); resultobj = Py_None;
12425     return resultobj;
12426     fail:
12427     return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_VListBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12432     PyObject *resultobj;
12433     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12434     bool result;
12435     PyObject * obj0 = 0 ;
12436     char *kwnames[] = {
12437         (char *) "self", NULL
12438     };
12439
12440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_SelectAll",kwnames,&obj0)) goto fail;
12441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12442     if (SWIG_arg_fail(1)) SWIG_fail;
12443     {
12444         PyThreadState* __tstate = wxPyBeginAllowThreads();
12445         result = (bool)(arg1)->SelectAll();
12446
12447         wxPyEndAllowThreads(__tstate);
12448         if (PyErr_Occurred()) SWIG_fail;
12449     }
12450     {
12451         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12452     }
12453     return resultobj;
12454     fail:
12455     return NULL;
12456 }
12457
12458
12459 static PyObject *_wrap_VListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12460     PyObject *resultobj;
12461     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12462     bool result;
12463     PyObject * obj0 = 0 ;
12464     char *kwnames[] = {
12465         (char *) "self", NULL
12466     };
12467
12468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_DeselectAll",kwnames,&obj0)) goto fail;
12469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12470     if (SWIG_arg_fail(1)) SWIG_fail;
12471     {
12472         PyThreadState* __tstate = wxPyBeginAllowThreads();
12473         result = (bool)(arg1)->DeselectAll();
12474
12475         wxPyEndAllowThreads(__tstate);
12476         if (PyErr_Occurred()) SWIG_fail;
12477     }
12478     {
12479         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12480     }
12481     return resultobj;
12482     fail:
12483     return NULL;
12484 }
12485
12486
12487 static PyObject *_wrap_VListBox_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12488     PyObject *resultobj;
12489     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12490     wxPoint *arg2 = 0 ;
12491     wxPoint temp2 ;
12492     PyObject * obj0 = 0 ;
12493     PyObject * obj1 = 0 ;
12494     char *kwnames[] = {
12495         (char *) "self",(char *) "pt", NULL
12496     };
12497
12498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetMargins",kwnames,&obj0,&obj1)) goto fail;
12499     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12500     if (SWIG_arg_fail(1)) SWIG_fail;
12501     {
12502         arg2 = &temp2;
12503         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12504     }
12505     {
12506         PyThreadState* __tstate = wxPyBeginAllowThreads();
12507         (arg1)->SetMargins((wxPoint const &)*arg2);
12508
12509         wxPyEndAllowThreads(__tstate);
12510         if (PyErr_Occurred()) SWIG_fail;
12511     }
12512     Py_INCREF(Py_None); resultobj = Py_None;
12513     return resultobj;
12514     fail:
12515     return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_VListBox_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
12520     PyObject *resultobj;
12521     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12522     int arg2 ;
12523     int arg3 ;
12524     PyObject * obj0 = 0 ;
12525     PyObject * obj1 = 0 ;
12526     PyObject * obj2 = 0 ;
12527     char *kwnames[] = {
12528         (char *) "self",(char *) "x",(char *) "y", NULL
12529     };
12530
12531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
12532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12533     if (SWIG_arg_fail(1)) SWIG_fail;
12534     {
12535         arg2 = (int)(SWIG_As_int(obj1));
12536         if (SWIG_arg_fail(2)) SWIG_fail;
12537     }
12538     {
12539         arg3 = (int)(SWIG_As_int(obj2));
12540         if (SWIG_arg_fail(3)) SWIG_fail;
12541     }
12542     {
12543         PyThreadState* __tstate = wxPyBeginAllowThreads();
12544         (arg1)->SetMargins(arg2,arg3);
12545
12546         wxPyEndAllowThreads(__tstate);
12547         if (PyErr_Occurred()) SWIG_fail;
12548     }
12549     Py_INCREF(Py_None); resultobj = Py_None;
12550     return resultobj;
12551     fail:
12552     return NULL;
12553 }
12554
12555
12556 static PyObject *_wrap_VListBox_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12557     PyObject *resultobj;
12558     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12559     wxColour *arg2 = 0 ;
12560     wxColour temp2 ;
12561     PyObject * obj0 = 0 ;
12562     PyObject * obj1 = 0 ;
12563     char *kwnames[] = {
12564         (char *) "self",(char *) "col", NULL
12565     };
12566
12567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
12568     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12569     if (SWIG_arg_fail(1)) SWIG_fail;
12570     {
12571         arg2 = &temp2;
12572         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12573     }
12574     {
12575         PyThreadState* __tstate = wxPyBeginAllowThreads();
12576         (arg1)->SetSelectionBackground((wxColour const &)*arg2);
12577
12578         wxPyEndAllowThreads(__tstate);
12579         if (PyErr_Occurred()) SWIG_fail;
12580     }
12581     Py_INCREF(Py_None); resultobj = Py_None;
12582     return resultobj;
12583     fail:
12584     return NULL;
12585 }
12586
12587
12588 static PyObject * VListBox_swigregister(PyObject *, PyObject *args) {
12589     PyObject *obj;
12590     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12591     SWIG_TypeClientData(SWIGTYPE_p_wxPyVListBox, obj);
12592     Py_INCREF(obj);
12593     return Py_BuildValue((char *)"");
12594 }
12595 static PyObject *_wrap_new_HtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12596     PyObject *resultobj;
12597     wxWindow *arg1 = (wxWindow *) 0 ;
12598     int arg2 = (int) wxID_ANY ;
12599     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12600     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12601     wxSize const &arg4_defvalue = wxDefaultSize ;
12602     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12603     long arg5 = (long) 0 ;
12604     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
12605     wxString *arg6 = (wxString *) &arg6_defvalue ;
12606     wxPyHtmlListBox *result;
12607     wxPoint temp3 ;
12608     wxSize temp4 ;
12609     bool temp6 = false ;
12610     PyObject * obj0 = 0 ;
12611     PyObject * obj1 = 0 ;
12612     PyObject * obj2 = 0 ;
12613     PyObject * obj3 = 0 ;
12614     PyObject * obj4 = 0 ;
12615     PyObject * obj5 = 0 ;
12616     char *kwnames[] = {
12617         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12618     };
12619
12620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_HtmlListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12622     if (SWIG_arg_fail(1)) SWIG_fail;
12623     if (obj1) {
12624         {
12625             arg2 = (int)(SWIG_As_int(obj1));
12626             if (SWIG_arg_fail(2)) SWIG_fail;
12627         }
12628     }
12629     if (obj2) {
12630         {
12631             arg3 = &temp3;
12632             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12633         }
12634     }
12635     if (obj3) {
12636         {
12637             arg4 = &temp4;
12638             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12639         }
12640     }
12641     if (obj4) {
12642         {
12643             arg5 = (long)(SWIG_As_long(obj4));
12644             if (SWIG_arg_fail(5)) SWIG_fail;
12645         }
12646     }
12647     if (obj5) {
12648         {
12649             arg6 = wxString_in_helper(obj5);
12650             if (arg6 == NULL) SWIG_fail;
12651             temp6 = true;
12652         }
12653     }
12654     {
12655         if (!wxPyCheckForApp()) SWIG_fail;
12656         PyThreadState* __tstate = wxPyBeginAllowThreads();
12657         result = (wxPyHtmlListBox *)new wxPyHtmlListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12658
12659         wxPyEndAllowThreads(__tstate);
12660         if (PyErr_Occurred()) SWIG_fail;
12661     }
12662     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12663     {
12664         if (temp6)
12665         delete arg6;
12666     }
12667     return resultobj;
12668     fail:
12669     {
12670         if (temp6)
12671         delete arg6;
12672     }
12673     return NULL;
12674 }
12675
12676
12677 static PyObject *_wrap_new_PreHtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12678     PyObject *resultobj;
12679     wxPyHtmlListBox *result;
12680     char *kwnames[] = {
12681         NULL
12682     };
12683
12684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreHtmlListBox",kwnames)) goto fail;
12685     {
12686         if (!wxPyCheckForApp()) SWIG_fail;
12687         PyThreadState* __tstate = wxPyBeginAllowThreads();
12688         result = (wxPyHtmlListBox *)new wxPyHtmlListBox();
12689
12690         wxPyEndAllowThreads(__tstate);
12691         if (PyErr_Occurred()) SWIG_fail;
12692     }
12693     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12694     return resultobj;
12695     fail:
12696     return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_HtmlListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12701     PyObject *resultobj;
12702     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12703     PyObject *arg2 = (PyObject *) 0 ;
12704     PyObject *arg3 = (PyObject *) 0 ;
12705     PyObject * obj0 = 0 ;
12706     PyObject * obj1 = 0 ;
12707     PyObject * obj2 = 0 ;
12708     char *kwnames[] = {
12709         (char *) "self",(char *) "self",(char *) "_class", NULL
12710     };
12711
12712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HtmlListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
12713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12714     if (SWIG_arg_fail(1)) SWIG_fail;
12715     arg2 = obj1;
12716     arg3 = obj2;
12717     {
12718         PyThreadState* __tstate = wxPyBeginAllowThreads();
12719         (arg1)->_setCallbackInfo(arg2,arg3);
12720
12721         wxPyEndAllowThreads(__tstate);
12722         if (PyErr_Occurred()) SWIG_fail;
12723     }
12724     Py_INCREF(Py_None); resultobj = Py_None;
12725     return resultobj;
12726     fail:
12727     return NULL;
12728 }
12729
12730
12731 static PyObject *_wrap_HtmlListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12732     PyObject *resultobj;
12733     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12734     wxWindow *arg2 = (wxWindow *) 0 ;
12735     int arg3 = (int) wxID_ANY ;
12736     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12737     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12738     wxSize const &arg5_defvalue = wxDefaultSize ;
12739     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12740     long arg6 = (long) 0 ;
12741     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
12742     wxString *arg7 = (wxString *) &arg7_defvalue ;
12743     bool result;
12744     wxPoint temp4 ;
12745     wxSize temp5 ;
12746     bool temp7 = false ;
12747     PyObject * obj0 = 0 ;
12748     PyObject * obj1 = 0 ;
12749     PyObject * obj2 = 0 ;
12750     PyObject * obj3 = 0 ;
12751     PyObject * obj4 = 0 ;
12752     PyObject * obj5 = 0 ;
12753     PyObject * obj6 = 0 ;
12754     char *kwnames[] = {
12755         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12756     };
12757
12758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:HtmlListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12760     if (SWIG_arg_fail(1)) SWIG_fail;
12761     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12762     if (SWIG_arg_fail(2)) SWIG_fail;
12763     if (obj2) {
12764         {
12765             arg3 = (int)(SWIG_As_int(obj2));
12766             if (SWIG_arg_fail(3)) SWIG_fail;
12767         }
12768     }
12769     if (obj3) {
12770         {
12771             arg4 = &temp4;
12772             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12773         }
12774     }
12775     if (obj4) {
12776         {
12777             arg5 = &temp5;
12778             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12779         }
12780     }
12781     if (obj5) {
12782         {
12783             arg6 = (long)(SWIG_As_long(obj5));
12784             if (SWIG_arg_fail(6)) SWIG_fail;
12785         }
12786     }
12787     if (obj6) {
12788         {
12789             arg7 = wxString_in_helper(obj6);
12790             if (arg7 == NULL) SWIG_fail;
12791             temp7 = true;
12792         }
12793     }
12794     {
12795         PyThreadState* __tstate = wxPyBeginAllowThreads();
12796         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12797
12798         wxPyEndAllowThreads(__tstate);
12799         if (PyErr_Occurred()) SWIG_fail;
12800     }
12801     {
12802         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12803     }
12804     {
12805         if (temp7)
12806         delete arg7;
12807     }
12808     return resultobj;
12809     fail:
12810     {
12811         if (temp7)
12812         delete arg7;
12813     }
12814     return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_HtmlListBox_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
12819     PyObject *resultobj;
12820     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12821     PyObject * obj0 = 0 ;
12822     char *kwnames[] = {
12823         (char *) "self", NULL
12824     };
12825
12826     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_RefreshAll",kwnames,&obj0)) goto fail;
12827     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12828     if (SWIG_arg_fail(1)) SWIG_fail;
12829     {
12830         PyThreadState* __tstate = wxPyBeginAllowThreads();
12831         (arg1)->RefreshAll();
12832
12833         wxPyEndAllowThreads(__tstate);
12834         if (PyErr_Occurred()) SWIG_fail;
12835     }
12836     Py_INCREF(Py_None); resultobj = Py_None;
12837     return resultobj;
12838     fail:
12839     return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_HtmlListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12844     PyObject *resultobj;
12845     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12846     size_t arg2 ;
12847     PyObject * obj0 = 0 ;
12848     PyObject * obj1 = 0 ;
12849     char *kwnames[] = {
12850         (char *) "self",(char *) "count", NULL
12851     };
12852
12853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HtmlListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12855     if (SWIG_arg_fail(1)) SWIG_fail;
12856     {
12857         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12858         if (SWIG_arg_fail(2)) SWIG_fail;
12859     }
12860     {
12861         PyThreadState* __tstate = wxPyBeginAllowThreads();
12862         (arg1)->SetItemCount(arg2);
12863
12864         wxPyEndAllowThreads(__tstate);
12865         if (PyErr_Occurred()) SWIG_fail;
12866     }
12867     Py_INCREF(Py_None); resultobj = Py_None;
12868     return resultobj;
12869     fail:
12870     return NULL;
12871 }
12872
12873
12874 static PyObject *_wrap_HtmlListBox_GetFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
12875     PyObject *resultobj;
12876     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12877     wxFileSystem *result;
12878     PyObject * obj0 = 0 ;
12879     char *kwnames[] = {
12880         (char *) "self", NULL
12881     };
12882
12883     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_GetFileSystem",kwnames,&obj0)) goto fail;
12884     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12885     if (SWIG_arg_fail(1)) SWIG_fail;
12886     {
12887         PyThreadState* __tstate = wxPyBeginAllowThreads();
12888         {
12889             wxFileSystem &_result_ref = (arg1)->GetFileSystem();
12890             result = (wxFileSystem *) &_result_ref;
12891         }
12892
12893         wxPyEndAllowThreads(__tstate);
12894         if (PyErr_Occurred()) SWIG_fail;
12895     }
12896     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileSystem, 0);
12897     return resultobj;
12898     fail:
12899     return NULL;
12900 }
12901
12902
12903 static PyObject * HtmlListBox_swigregister(PyObject *, PyObject *args) {
12904     PyObject *obj;
12905     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12906     SWIG_TypeClientData(SWIGTYPE_p_wxPyHtmlListBox, obj);
12907     Py_INCREF(obj);
12908     return Py_BuildValue((char *)"");
12909 }
12910 static PyObject *_wrap_new_TaskBarIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12911     PyObject *resultobj;
12912     wxPyTaskBarIcon *result;
12913     char *kwnames[] = {
12914         NULL
12915     };
12916
12917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TaskBarIcon",kwnames)) goto fail;
12918     {
12919         if (!wxPyCheckForApp()) SWIG_fail;
12920         PyThreadState* __tstate = wxPyBeginAllowThreads();
12921         result = (wxPyTaskBarIcon *)new wxPyTaskBarIcon();
12922
12923         wxPyEndAllowThreads(__tstate);
12924         if (PyErr_Occurred()) SWIG_fail;
12925     }
12926     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTaskBarIcon, 1);
12927     return resultobj;
12928     fail:
12929     return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_TaskBarIcon__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12934     PyObject *resultobj;
12935     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12936     PyObject *arg2 = (PyObject *) 0 ;
12937     PyObject *arg3 = (PyObject *) 0 ;
12938     int arg4 ;
12939     PyObject * obj0 = 0 ;
12940     PyObject * obj1 = 0 ;
12941     PyObject * obj2 = 0 ;
12942     PyObject * obj3 = 0 ;
12943     char *kwnames[] = {
12944         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12945     };
12946
12947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TaskBarIcon__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12949     if (SWIG_arg_fail(1)) SWIG_fail;
12950     arg2 = obj1;
12951     arg3 = obj2;
12952     {
12953         arg4 = (int)(SWIG_As_int(obj3));
12954         if (SWIG_arg_fail(4)) SWIG_fail;
12955     }
12956     {
12957         PyThreadState* __tstate = wxPyBeginAllowThreads();
12958         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12959
12960         wxPyEndAllowThreads(__tstate);
12961         if (PyErr_Occurred()) SWIG_fail;
12962     }
12963     Py_INCREF(Py_None); resultobj = Py_None;
12964     return resultobj;
12965     fail:
12966     return NULL;
12967 }
12968
12969
12970 static PyObject *_wrap_TaskBarIcon_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
12971     PyObject *resultobj;
12972     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12973     PyObject * obj0 = 0 ;
12974     char *kwnames[] = {
12975         (char *) "self", NULL
12976     };
12977
12978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_Destroy",kwnames,&obj0)) goto fail;
12979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12980     if (SWIG_arg_fail(1)) SWIG_fail;
12981     {
12982         PyThreadState* __tstate = wxPyBeginAllowThreads();
12983         wxPyTaskBarIcon_Destroy(arg1);
12984
12985         wxPyEndAllowThreads(__tstate);
12986         if (PyErr_Occurred()) SWIG_fail;
12987     }
12988     Py_INCREF(Py_None); resultobj = Py_None;
12989     return resultobj;
12990     fail:
12991     return NULL;
12992 }
12993
12994
12995 static PyObject *_wrap_TaskBarIcon_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12996     PyObject *resultobj;
12997     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12998     bool result;
12999     PyObject * obj0 = 0 ;
13000     char *kwnames[] = {
13001         (char *) "self", NULL
13002     };
13003
13004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsOk",kwnames,&obj0)) goto fail;
13005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13006     if (SWIG_arg_fail(1)) SWIG_fail;
13007     {
13008         PyThreadState* __tstate = wxPyBeginAllowThreads();
13009         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsOk();
13010
13011         wxPyEndAllowThreads(__tstate);
13012         if (PyErr_Occurred()) SWIG_fail;
13013     }
13014     {
13015         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13016     }
13017     return resultobj;
13018     fail:
13019     return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_TaskBarIcon_IsIconInstalled(PyObject *, PyObject *args, PyObject *kwargs) {
13024     PyObject *resultobj;
13025     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13026     bool result;
13027     PyObject * obj0 = 0 ;
13028     char *kwnames[] = {
13029         (char *) "self", NULL
13030     };
13031
13032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsIconInstalled",kwnames,&obj0)) goto fail;
13033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13034     if (SWIG_arg_fail(1)) SWIG_fail;
13035     {
13036         PyThreadState* __tstate = wxPyBeginAllowThreads();
13037         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsIconInstalled();
13038
13039         wxPyEndAllowThreads(__tstate);
13040         if (PyErr_Occurred()) SWIG_fail;
13041     }
13042     {
13043         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13044     }
13045     return resultobj;
13046     fail:
13047     return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_TaskBarIcon_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13052     PyObject *resultobj;
13053     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13054     wxIcon *arg2 = 0 ;
13055     wxString const &arg3_defvalue = wxPyEmptyString ;
13056     wxString *arg3 = (wxString *) &arg3_defvalue ;
13057     bool result;
13058     bool temp3 = false ;
13059     PyObject * obj0 = 0 ;
13060     PyObject * obj1 = 0 ;
13061     PyObject * obj2 = 0 ;
13062     char *kwnames[] = {
13063         (char *) "self",(char *) "icon",(char *) "tooltip", NULL
13064     };
13065
13066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TaskBarIcon_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13068     if (SWIG_arg_fail(1)) SWIG_fail;
13069     {
13070         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13071         if (SWIG_arg_fail(2)) SWIG_fail;
13072         if (arg2 == NULL) {
13073             SWIG_null_ref("wxIcon");
13074         }
13075         if (SWIG_arg_fail(2)) SWIG_fail;
13076     }
13077     if (obj2) {
13078         {
13079             arg3 = wxString_in_helper(obj2);
13080             if (arg3 == NULL) SWIG_fail;
13081             temp3 = true;
13082         }
13083     }
13084     {
13085         PyThreadState* __tstate = wxPyBeginAllowThreads();
13086         result = (bool)(arg1)->SetIcon((wxIcon const &)*arg2,(wxString const &)*arg3);
13087
13088         wxPyEndAllowThreads(__tstate);
13089         if (PyErr_Occurred()) SWIG_fail;
13090     }
13091     {
13092         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13093     }
13094     {
13095         if (temp3)
13096         delete arg3;
13097     }
13098     return resultobj;
13099     fail:
13100     {
13101         if (temp3)
13102         delete arg3;
13103     }
13104     return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_TaskBarIcon_RemoveIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13109     PyObject *resultobj;
13110     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13111     bool result;
13112     PyObject * obj0 = 0 ;
13113     char *kwnames[] = {
13114         (char *) "self", NULL
13115     };
13116
13117     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_RemoveIcon",kwnames,&obj0)) goto fail;
13118     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13119     if (SWIG_arg_fail(1)) SWIG_fail;
13120     {
13121         PyThreadState* __tstate = wxPyBeginAllowThreads();
13122         result = (bool)(arg1)->RemoveIcon();
13123
13124         wxPyEndAllowThreads(__tstate);
13125         if (PyErr_Occurred()) SWIG_fail;
13126     }
13127     {
13128         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13129     }
13130     return resultobj;
13131     fail:
13132     return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_TaskBarIcon_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
13137     PyObject *resultobj;
13138     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13139     wxMenu *arg2 = (wxMenu *) 0 ;
13140     bool result;
13141     PyObject * obj0 = 0 ;
13142     PyObject * obj1 = 0 ;
13143     char *kwnames[] = {
13144         (char *) "self",(char *) "menu", NULL
13145     };
13146
13147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TaskBarIcon_PopupMenu",kwnames,&obj0,&obj1)) goto fail;
13148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13149     if (SWIG_arg_fail(1)) SWIG_fail;
13150     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
13151     if (SWIG_arg_fail(2)) SWIG_fail;
13152     {
13153         PyThreadState* __tstate = wxPyBeginAllowThreads();
13154         result = (bool)(arg1)->PopupMenu(arg2);
13155
13156         wxPyEndAllowThreads(__tstate);
13157         if (PyErr_Occurred()) SWIG_fail;
13158     }
13159     {
13160         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13161     }
13162     return resultobj;
13163     fail:
13164     return NULL;
13165 }
13166
13167
13168 static PyObject * TaskBarIcon_swigregister(PyObject *, PyObject *args) {
13169     PyObject *obj;
13170     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13171     SWIG_TypeClientData(SWIGTYPE_p_wxPyTaskBarIcon, obj);
13172     Py_INCREF(obj);
13173     return Py_BuildValue((char *)"");
13174 }
13175 static PyObject *_wrap_new_TaskBarIconEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13176     PyObject *resultobj;
13177     wxEventType arg1 ;
13178     wxTaskBarIcon *arg2 = (wxTaskBarIcon *) 0 ;
13179     wxTaskBarIconEvent *result;
13180     PyObject * obj0 = 0 ;
13181     PyObject * obj1 = 0 ;
13182     char *kwnames[] = {
13183         (char *) "evtType",(char *) "tbIcon", NULL
13184     };
13185
13186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_TaskBarIconEvent",kwnames,&obj0,&obj1)) goto fail;
13187     {
13188         arg1 = (wxEventType)(SWIG_As_int(obj0));
13189         if (SWIG_arg_fail(1)) SWIG_fail;
13190     }
13191     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13192     if (SWIG_arg_fail(2)) SWIG_fail;
13193     {
13194         PyThreadState* __tstate = wxPyBeginAllowThreads();
13195         result = (wxTaskBarIconEvent *)new wxTaskBarIconEvent(arg1,arg2);
13196
13197         wxPyEndAllowThreads(__tstate);
13198         if (PyErr_Occurred()) SWIG_fail;
13199     }
13200     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTaskBarIconEvent, 1);
13201     return resultobj;
13202     fail:
13203     return NULL;
13204 }
13205
13206
13207 static PyObject * TaskBarIconEvent_swigregister(PyObject *, PyObject *args) {
13208     PyObject *obj;
13209     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13210     SWIG_TypeClientData(SWIGTYPE_p_wxTaskBarIconEvent, obj);
13211     Py_INCREF(obj);
13212     return Py_BuildValue((char *)"");
13213 }
13214 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
13215     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
13216     return 1;
13217 }
13218
13219
13220 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
13221     PyObject *pyobj;
13222
13223     {
13224 #if wxUSE_UNICODE
13225         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13226 #else
13227         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13228 #endif
13229     }
13230     return pyobj;
13231 }
13232
13233
13234 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
13235     PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
13236     return 1;
13237 }
13238
13239
13240 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
13241     PyObject *pyobj;
13242
13243     {
13244 #if wxUSE_UNICODE
13245         pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13246 #else
13247         pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13248 #endif
13249     }
13250     return pyobj;
13251 }
13252
13253
13254 static int _wrap_DirDialogNameStr_set(PyObject *) {
13255     PyErr_SetString(PyExc_TypeError,"Variable DirDialogNameStr is read-only.");
13256     return 1;
13257 }
13258
13259
13260 static PyObject *_wrap_DirDialogNameStr_get(void) {
13261     PyObject *pyobj;
13262
13263     {
13264 #if wxUSE_UNICODE
13265         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13266 #else
13267         pyobj = PyString_FromStringAndSize((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13268 #endif
13269     }
13270     return pyobj;
13271 }
13272
13273
13274 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
13275     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
13276     return 1;
13277 }
13278
13279
13280 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
13281     PyObject *pyobj;
13282
13283     {
13284 #if wxUSE_UNICODE
13285         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13286 #else
13287         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13288 #endif
13289     }
13290     return pyobj;
13291 }
13292
13293
13294 static int _wrap_GetTextFromUserPromptStr_set(PyObject *) {
13295     PyErr_SetString(PyExc_TypeError,"Variable GetTextFromUserPromptStr is read-only.");
13296     return 1;
13297 }
13298
13299
13300 static PyObject *_wrap_GetTextFromUserPromptStr_get(void) {
13301     PyObject *pyobj;
13302
13303     {
13304 #if wxUSE_UNICODE
13305         pyobj = PyUnicode_FromWideChar((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13306 #else
13307         pyobj = PyString_FromStringAndSize((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13308 #endif
13309     }
13310     return pyobj;
13311 }
13312
13313
13314 static int _wrap_MessageBoxCaptionStr_set(PyObject *) {
13315     PyErr_SetString(PyExc_TypeError,"Variable MessageBoxCaptionStr is read-only.");
13316     return 1;
13317 }
13318
13319
13320 static PyObject *_wrap_MessageBoxCaptionStr_get(void) {
13321     PyObject *pyobj;
13322
13323     {
13324 #if wxUSE_UNICODE
13325         pyobj = PyUnicode_FromWideChar((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13326 #else
13327         pyobj = PyString_FromStringAndSize((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13328 #endif
13329     }
13330     return pyobj;
13331 }
13332
13333
13334 static PyObject *_wrap_new_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13335     PyObject *resultobj;
13336     wxColourData *result;
13337     char *kwnames[] = {
13338         NULL
13339     };
13340
13341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourData",kwnames)) goto fail;
13342     {
13343         PyThreadState* __tstate = wxPyBeginAllowThreads();
13344         result = (wxColourData *)new wxColourData();
13345
13346         wxPyEndAllowThreads(__tstate);
13347         if (PyErr_Occurred()) SWIG_fail;
13348     }
13349     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 1);
13350     return resultobj;
13351     fail:
13352     return NULL;
13353 }
13354
13355
13356 static PyObject *_wrap_delete_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13357     PyObject *resultobj;
13358     wxColourData *arg1 = (wxColourData *) 0 ;
13359     PyObject * obj0 = 0 ;
13360     char *kwnames[] = {
13361         (char *) "self", NULL
13362     };
13363
13364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourData",kwnames,&obj0)) goto fail;
13365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13366     if (SWIG_arg_fail(1)) SWIG_fail;
13367     {
13368         PyThreadState* __tstate = wxPyBeginAllowThreads();
13369         delete arg1;
13370
13371         wxPyEndAllowThreads(__tstate);
13372         if (PyErr_Occurred()) SWIG_fail;
13373     }
13374     Py_INCREF(Py_None); resultobj = Py_None;
13375     return resultobj;
13376     fail:
13377     return NULL;
13378 }
13379
13380
13381 static PyObject *_wrap_ColourData_GetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13382     PyObject *resultobj;
13383     wxColourData *arg1 = (wxColourData *) 0 ;
13384     bool result;
13385     PyObject * obj0 = 0 ;
13386     char *kwnames[] = {
13387         (char *) "self", NULL
13388     };
13389
13390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetChooseFull",kwnames,&obj0)) goto fail;
13391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13392     if (SWIG_arg_fail(1)) SWIG_fail;
13393     {
13394         PyThreadState* __tstate = wxPyBeginAllowThreads();
13395         result = (bool)(arg1)->GetChooseFull();
13396
13397         wxPyEndAllowThreads(__tstate);
13398         if (PyErr_Occurred()) SWIG_fail;
13399     }
13400     {
13401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13402     }
13403     return resultobj;
13404     fail:
13405     return NULL;
13406 }
13407
13408
13409 static PyObject *_wrap_ColourData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13410     PyObject *resultobj;
13411     wxColourData *arg1 = (wxColourData *) 0 ;
13412     wxColour result;
13413     PyObject * obj0 = 0 ;
13414     char *kwnames[] = {
13415         (char *) "self", NULL
13416     };
13417
13418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetColour",kwnames,&obj0)) goto fail;
13419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13420     if (SWIG_arg_fail(1)) SWIG_fail;
13421     {
13422         PyThreadState* __tstate = wxPyBeginAllowThreads();
13423         result = (arg1)->GetColour();
13424
13425         wxPyEndAllowThreads(__tstate);
13426         if (PyErr_Occurred()) SWIG_fail;
13427     }
13428     {
13429         wxColour * resultptr;
13430         resultptr = new wxColour((wxColour &)(result));
13431         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13432     }
13433     return resultobj;
13434     fail:
13435     return NULL;
13436 }
13437
13438
13439 static PyObject *_wrap_ColourData_GetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13440     PyObject *resultobj;
13441     wxColourData *arg1 = (wxColourData *) 0 ;
13442     int arg2 ;
13443     wxColour result;
13444     PyObject * obj0 = 0 ;
13445     PyObject * obj1 = 0 ;
13446     char *kwnames[] = {
13447         (char *) "self",(char *) "i", NULL
13448     };
13449
13450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_GetCustomColour",kwnames,&obj0,&obj1)) goto fail;
13451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13452     if (SWIG_arg_fail(1)) SWIG_fail;
13453     {
13454         arg2 = (int)(SWIG_As_int(obj1));
13455         if (SWIG_arg_fail(2)) SWIG_fail;
13456     }
13457     {
13458         PyThreadState* __tstate = wxPyBeginAllowThreads();
13459         result = (arg1)->GetCustomColour(arg2);
13460
13461         wxPyEndAllowThreads(__tstate);
13462         if (PyErr_Occurred()) SWIG_fail;
13463     }
13464     {
13465         wxColour * resultptr;
13466         resultptr = new wxColour((wxColour &)(result));
13467         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13468     }
13469     return resultobj;
13470     fail:
13471     return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_ColourData_SetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13476     PyObject *resultobj;
13477     wxColourData *arg1 = (wxColourData *) 0 ;
13478     int arg2 ;
13479     PyObject * obj0 = 0 ;
13480     PyObject * obj1 = 0 ;
13481     char *kwnames[] = {
13482         (char *) "self",(char *) "flag", NULL
13483     };
13484
13485     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetChooseFull",kwnames,&obj0,&obj1)) goto fail;
13486     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13487     if (SWIG_arg_fail(1)) SWIG_fail;
13488     {
13489         arg2 = (int)(SWIG_As_int(obj1));
13490         if (SWIG_arg_fail(2)) SWIG_fail;
13491     }
13492     {
13493         PyThreadState* __tstate = wxPyBeginAllowThreads();
13494         (arg1)->SetChooseFull(arg2);
13495
13496         wxPyEndAllowThreads(__tstate);
13497         if (PyErr_Occurred()) SWIG_fail;
13498     }
13499     Py_INCREF(Py_None); resultobj = Py_None;
13500     return resultobj;
13501     fail:
13502     return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_ColourData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13507     PyObject *resultobj;
13508     wxColourData *arg1 = (wxColourData *) 0 ;
13509     wxColour *arg2 = 0 ;
13510     wxColour temp2 ;
13511     PyObject * obj0 = 0 ;
13512     PyObject * obj1 = 0 ;
13513     char *kwnames[] = {
13514         (char *) "self",(char *) "colour", NULL
13515     };
13516
13517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetColour",kwnames,&obj0,&obj1)) goto fail;
13518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13519     if (SWIG_arg_fail(1)) SWIG_fail;
13520     {
13521         arg2 = &temp2;
13522         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13523     }
13524     {
13525         PyThreadState* __tstate = wxPyBeginAllowThreads();
13526         (arg1)->SetColour((wxColour const &)*arg2);
13527
13528         wxPyEndAllowThreads(__tstate);
13529         if (PyErr_Occurred()) SWIG_fail;
13530     }
13531     Py_INCREF(Py_None); resultobj = Py_None;
13532     return resultobj;
13533     fail:
13534     return NULL;
13535 }
13536
13537
13538 static PyObject *_wrap_ColourData_SetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13539     PyObject *resultobj;
13540     wxColourData *arg1 = (wxColourData *) 0 ;
13541     int arg2 ;
13542     wxColour *arg3 = 0 ;
13543     wxColour temp3 ;
13544     PyObject * obj0 = 0 ;
13545     PyObject * obj1 = 0 ;
13546     PyObject * obj2 = 0 ;
13547     char *kwnames[] = {
13548         (char *) "self",(char *) "i",(char *) "colour", NULL
13549     };
13550
13551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourData_SetCustomColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13553     if (SWIG_arg_fail(1)) SWIG_fail;
13554     {
13555         arg2 = (int)(SWIG_As_int(obj1));
13556         if (SWIG_arg_fail(2)) SWIG_fail;
13557     }
13558     {
13559         arg3 = &temp3;
13560         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13561     }
13562     {
13563         PyThreadState* __tstate = wxPyBeginAllowThreads();
13564         (arg1)->SetCustomColour(arg2,(wxColour const &)*arg3);
13565
13566         wxPyEndAllowThreads(__tstate);
13567         if (PyErr_Occurred()) SWIG_fail;
13568     }
13569     Py_INCREF(Py_None); resultobj = Py_None;
13570     return resultobj;
13571     fail:
13572     return NULL;
13573 }
13574
13575
13576 static PyObject * ColourData_swigregister(PyObject *, PyObject *args) {
13577     PyObject *obj;
13578     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13579     SWIG_TypeClientData(SWIGTYPE_p_wxColourData, obj);
13580     Py_INCREF(obj);
13581     return Py_BuildValue((char *)"");
13582 }
13583 static PyObject *_wrap_new_ColourDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13584     PyObject *resultobj;
13585     wxWindow *arg1 = (wxWindow *) 0 ;
13586     wxColourData *arg2 = (wxColourData *) NULL ;
13587     wxColourDialog *result;
13588     PyObject * obj0 = 0 ;
13589     PyObject * obj1 = 0 ;
13590     char *kwnames[] = {
13591         (char *) "parent",(char *) "data", NULL
13592     };
13593
13594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_ColourDialog",kwnames,&obj0,&obj1)) goto fail;
13595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13596     if (SWIG_arg_fail(1)) SWIG_fail;
13597     if (obj1) {
13598         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13599         if (SWIG_arg_fail(2)) SWIG_fail;
13600     }
13601     {
13602         if (!wxPyCheckForApp()) SWIG_fail;
13603         PyThreadState* __tstate = wxPyBeginAllowThreads();
13604         result = (wxColourDialog *)new wxColourDialog(arg1,arg2);
13605
13606         wxPyEndAllowThreads(__tstate);
13607         if (PyErr_Occurred()) SWIG_fail;
13608     }
13609     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDialog, 1);
13610     return resultobj;
13611     fail:
13612     return NULL;
13613 }
13614
13615
13616 static PyObject *_wrap_ColourDialog_GetColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13617     PyObject *resultobj;
13618     wxColourDialog *arg1 = (wxColourDialog *) 0 ;
13619     wxColourData *result;
13620     PyObject * obj0 = 0 ;
13621     char *kwnames[] = {
13622         (char *) "self", NULL
13623     };
13624
13625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourDialog_GetColourData",kwnames,&obj0)) goto fail;
13626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDialog, SWIG_POINTER_EXCEPTION | 0);
13627     if (SWIG_arg_fail(1)) SWIG_fail;
13628     {
13629         PyThreadState* __tstate = wxPyBeginAllowThreads();
13630         {
13631             wxColourData &_result_ref = (arg1)->GetColourData();
13632             result = (wxColourData *) &_result_ref;
13633         }
13634
13635         wxPyEndAllowThreads(__tstate);
13636         if (PyErr_Occurred()) SWIG_fail;
13637     }
13638     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 0);
13639     return resultobj;
13640     fail:
13641     return NULL;
13642 }
13643
13644
13645 static PyObject * ColourDialog_swigregister(PyObject *, PyObject *args) {
13646     PyObject *obj;
13647     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13648     SWIG_TypeClientData(SWIGTYPE_p_wxColourDialog, obj);
13649     Py_INCREF(obj);
13650     return Py_BuildValue((char *)"");
13651 }
13652 static PyObject *_wrap_new_DirDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13653     PyObject *resultobj;
13654     wxWindow *arg1 = (wxWindow *) 0 ;
13655     wxString const &arg2_defvalue = wxPyDirSelectorPromptStr ;
13656     wxString *arg2 = (wxString *) &arg2_defvalue ;
13657     wxString const &arg3_defvalue = wxPyEmptyString ;
13658     wxString *arg3 = (wxString *) &arg3_defvalue ;
13659     long arg4 = (long) 0 ;
13660     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13661     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13662     wxSize const &arg6_defvalue = wxDefaultSize ;
13663     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13664     wxString const &arg7_defvalue = wxPyDirDialogNameStr ;
13665     wxString *arg7 = (wxString *) &arg7_defvalue ;
13666     wxDirDialog *result;
13667     bool temp2 = false ;
13668     bool temp3 = false ;
13669     wxPoint temp5 ;
13670     wxSize temp6 ;
13671     bool temp7 = false ;
13672     PyObject * obj0 = 0 ;
13673     PyObject * obj1 = 0 ;
13674     PyObject * obj2 = 0 ;
13675     PyObject * obj3 = 0 ;
13676     PyObject * obj4 = 0 ;
13677     PyObject * obj5 = 0 ;
13678     PyObject * obj6 = 0 ;
13679     char *kwnames[] = {
13680         (char *) "parent",(char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL
13681     };
13682
13683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DirDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13685     if (SWIG_arg_fail(1)) SWIG_fail;
13686     if (obj1) {
13687         {
13688             arg2 = wxString_in_helper(obj1);
13689             if (arg2 == NULL) SWIG_fail;
13690             temp2 = true;
13691         }
13692     }
13693     if (obj2) {
13694         {
13695             arg3 = wxString_in_helper(obj2);
13696             if (arg3 == NULL) SWIG_fail;
13697             temp3 = true;
13698         }
13699     }
13700     if (obj3) {
13701         {
13702             arg4 = (long)(SWIG_As_long(obj3));
13703             if (SWIG_arg_fail(4)) SWIG_fail;
13704         }
13705     }
13706     if (obj4) {
13707         {
13708             arg5 = &temp5;
13709             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13710         }
13711     }
13712     if (obj5) {
13713         {
13714             arg6 = &temp6;
13715             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13716         }
13717     }
13718     if (obj6) {
13719         {
13720             arg7 = wxString_in_helper(obj6);
13721             if (arg7 == NULL) SWIG_fail;
13722             temp7 = true;
13723         }
13724     }
13725     {
13726         if (!wxPyCheckForApp()) SWIG_fail;
13727         PyThreadState* __tstate = wxPyBeginAllowThreads();
13728         result = (wxDirDialog *)new wxDirDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxString const &)*arg7);
13729
13730         wxPyEndAllowThreads(__tstate);
13731         if (PyErr_Occurred()) SWIG_fail;
13732     }
13733     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirDialog, 1);
13734     {
13735         if (temp2)
13736         delete arg2;
13737     }
13738     {
13739         if (temp3)
13740         delete arg3;
13741     }
13742     {
13743         if (temp7)
13744         delete arg7;
13745     }
13746     return resultobj;
13747     fail:
13748     {
13749         if (temp2)
13750         delete arg2;
13751     }
13752     {
13753         if (temp3)
13754         delete arg3;
13755     }
13756     {
13757         if (temp7)
13758         delete arg7;
13759     }
13760     return NULL;
13761 }
13762
13763
13764 static PyObject *_wrap_DirDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13765     PyObject *resultobj;
13766     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13767     wxString result;
13768     PyObject * obj0 = 0 ;
13769     char *kwnames[] = {
13770         (char *) "self", NULL
13771     };
13772
13773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetPath",kwnames,&obj0)) goto fail;
13774     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13775     if (SWIG_arg_fail(1)) SWIG_fail;
13776     {
13777         PyThreadState* __tstate = wxPyBeginAllowThreads();
13778         result = (arg1)->GetPath();
13779
13780         wxPyEndAllowThreads(__tstate);
13781         if (PyErr_Occurred()) SWIG_fail;
13782     }
13783     {
13784 #if wxUSE_UNICODE
13785         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13786 #else
13787         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13788 #endif
13789     }
13790     return resultobj;
13791     fail:
13792     return NULL;
13793 }
13794
13795
13796 static PyObject *_wrap_DirDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13797     PyObject *resultobj;
13798     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13799     wxString result;
13800     PyObject * obj0 = 0 ;
13801     char *kwnames[] = {
13802         (char *) "self", NULL
13803     };
13804
13805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetMessage",kwnames,&obj0)) goto fail;
13806     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13807     if (SWIG_arg_fail(1)) SWIG_fail;
13808     {
13809         PyThreadState* __tstate = wxPyBeginAllowThreads();
13810         result = (arg1)->GetMessage();
13811
13812         wxPyEndAllowThreads(__tstate);
13813         if (PyErr_Occurred()) SWIG_fail;
13814     }
13815     {
13816 #if wxUSE_UNICODE
13817         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13818 #else
13819         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13820 #endif
13821     }
13822     return resultobj;
13823     fail:
13824     return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_DirDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
13829     PyObject *resultobj;
13830     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13831     long result;
13832     PyObject * obj0 = 0 ;
13833     char *kwnames[] = {
13834         (char *) "self", NULL
13835     };
13836
13837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetStyle",kwnames,&obj0)) goto fail;
13838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13839     if (SWIG_arg_fail(1)) SWIG_fail;
13840     {
13841         PyThreadState* __tstate = wxPyBeginAllowThreads();
13842         result = (long)(arg1)->GetStyle();
13843
13844         wxPyEndAllowThreads(__tstate);
13845         if (PyErr_Occurred()) SWIG_fail;
13846     }
13847     {
13848         resultobj = SWIG_From_long((long)(result));
13849     }
13850     return resultobj;
13851     fail:
13852     return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_DirDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13857     PyObject *resultobj;
13858     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13859     wxString *arg2 = 0 ;
13860     bool temp2 = false ;
13861     PyObject * obj0 = 0 ;
13862     PyObject * obj1 = 0 ;
13863     char *kwnames[] = {
13864         (char *) "self",(char *) "message", NULL
13865     };
13866
13867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
13868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13869     if (SWIG_arg_fail(1)) SWIG_fail;
13870     {
13871         arg2 = wxString_in_helper(obj1);
13872         if (arg2 == NULL) SWIG_fail;
13873         temp2 = true;
13874     }
13875     {
13876         PyThreadState* __tstate = wxPyBeginAllowThreads();
13877         (arg1)->SetMessage((wxString const &)*arg2);
13878
13879         wxPyEndAllowThreads(__tstate);
13880         if (PyErr_Occurred()) SWIG_fail;
13881     }
13882     Py_INCREF(Py_None); resultobj = Py_None;
13883     {
13884         if (temp2)
13885         delete arg2;
13886     }
13887     return resultobj;
13888     fail:
13889     {
13890         if (temp2)
13891         delete arg2;
13892     }
13893     return NULL;
13894 }
13895
13896
13897 static PyObject *_wrap_DirDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13898     PyObject *resultobj;
13899     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13900     wxString *arg2 = 0 ;
13901     bool temp2 = false ;
13902     PyObject * obj0 = 0 ;
13903     PyObject * obj1 = 0 ;
13904     char *kwnames[] = {
13905         (char *) "self",(char *) "path", NULL
13906     };
13907
13908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
13909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13910     if (SWIG_arg_fail(1)) SWIG_fail;
13911     {
13912         arg2 = wxString_in_helper(obj1);
13913         if (arg2 == NULL) SWIG_fail;
13914         temp2 = true;
13915     }
13916     {
13917         PyThreadState* __tstate = wxPyBeginAllowThreads();
13918         (arg1)->SetPath((wxString const &)*arg2);
13919
13920         wxPyEndAllowThreads(__tstate);
13921         if (PyErr_Occurred()) SWIG_fail;
13922     }
13923     Py_INCREF(Py_None); resultobj = Py_None;
13924     {
13925         if (temp2)
13926         delete arg2;
13927     }
13928     return resultobj;
13929     fail:
13930     {
13931         if (temp2)
13932         delete arg2;
13933     }
13934     return NULL;
13935 }
13936
13937
13938 static PyObject * DirDialog_swigregister(PyObject *, PyObject *args) {
13939     PyObject *obj;
13940     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13941     SWIG_TypeClientData(SWIGTYPE_p_wxDirDialog, obj);
13942     Py_INCREF(obj);
13943     return Py_BuildValue((char *)"");
13944 }
13945 static PyObject *_wrap_new_FileDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13946     PyObject *resultobj;
13947     wxWindow *arg1 = (wxWindow *) 0 ;
13948     wxString const &arg2_defvalue = wxPyFileSelectorPromptStr ;
13949     wxString *arg2 = (wxString *) &arg2_defvalue ;
13950     wxString const &arg3_defvalue = wxPyEmptyString ;
13951     wxString *arg3 = (wxString *) &arg3_defvalue ;
13952     wxString const &arg4_defvalue = wxPyEmptyString ;
13953     wxString *arg4 = (wxString *) &arg4_defvalue ;
13954     wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
13955     wxString *arg5 = (wxString *) &arg5_defvalue ;
13956     long arg6 = (long) 0 ;
13957     wxPoint const &arg7_defvalue = wxDefaultPosition ;
13958     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
13959     wxFileDialog *result;
13960     bool temp2 = false ;
13961     bool temp3 = false ;
13962     bool temp4 = false ;
13963     bool temp5 = false ;
13964     wxPoint temp7 ;
13965     PyObject * obj0 = 0 ;
13966     PyObject * obj1 = 0 ;
13967     PyObject * obj2 = 0 ;
13968     PyObject * obj3 = 0 ;
13969     PyObject * obj4 = 0 ;
13970     PyObject * obj5 = 0 ;
13971     PyObject * obj6 = 0 ;
13972     char *kwnames[] = {
13973         (char *) "parent",(char *) "message",(char *) "defaultDir",(char *) "defaultFile",(char *) "wildcard",(char *) "style",(char *) "pos", NULL
13974     };
13975
13976     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_FileDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13977     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13978     if (SWIG_arg_fail(1)) SWIG_fail;
13979     if (obj1) {
13980         {
13981             arg2 = wxString_in_helper(obj1);
13982             if (arg2 == NULL) SWIG_fail;
13983             temp2 = true;
13984         }
13985     }
13986     if (obj2) {
13987         {
13988             arg3 = wxString_in_helper(obj2);
13989             if (arg3 == NULL) SWIG_fail;
13990             temp3 = true;
13991         }
13992     }
13993     if (obj3) {
13994         {
13995             arg4 = wxString_in_helper(obj3);
13996             if (arg4 == NULL) SWIG_fail;
13997             temp4 = true;
13998         }
13999     }
14000     if (obj4) {
14001         {
14002             arg5 = wxString_in_helper(obj4);
14003             if (arg5 == NULL) SWIG_fail;
14004             temp5 = true;
14005         }
14006     }
14007     if (obj5) {
14008         {
14009             arg6 = (long)(SWIG_As_long(obj5));
14010             if (SWIG_arg_fail(6)) SWIG_fail;
14011         }
14012     }
14013     if (obj6) {
14014         {
14015             arg7 = &temp7;
14016             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
14017         }
14018     }
14019     {
14020         if (!wxPyCheckForApp()) SWIG_fail;
14021         PyThreadState* __tstate = wxPyBeginAllowThreads();
14022         result = (wxFileDialog *)new wxFileDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,(wxPoint const &)*arg7);
14023
14024         wxPyEndAllowThreads(__tstate);
14025         if (PyErr_Occurred()) SWIG_fail;
14026     }
14027     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDialog, 1);
14028     {
14029         if (temp2)
14030         delete arg2;
14031     }
14032     {
14033         if (temp3)
14034         delete arg3;
14035     }
14036     {
14037         if (temp4)
14038         delete arg4;
14039     }
14040     {
14041         if (temp5)
14042         delete arg5;
14043     }
14044     return resultobj;
14045     fail:
14046     {
14047         if (temp2)
14048         delete arg2;
14049     }
14050     {
14051         if (temp3)
14052         delete arg3;
14053     }
14054     {
14055         if (temp4)
14056         delete arg4;
14057     }
14058     {
14059         if (temp5)
14060         delete arg5;
14061     }
14062     return NULL;
14063 }
14064
14065
14066 static PyObject *_wrap_FileDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14067     PyObject *resultobj;
14068     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14069     wxString *arg2 = 0 ;
14070     bool temp2 = false ;
14071     PyObject * obj0 = 0 ;
14072     PyObject * obj1 = 0 ;
14073     char *kwnames[] = {
14074         (char *) "self",(char *) "message", NULL
14075     };
14076
14077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
14078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14079     if (SWIG_arg_fail(1)) SWIG_fail;
14080     {
14081         arg2 = wxString_in_helper(obj1);
14082         if (arg2 == NULL) SWIG_fail;
14083         temp2 = true;
14084     }
14085     {
14086         PyThreadState* __tstate = wxPyBeginAllowThreads();
14087         (arg1)->SetMessage((wxString const &)*arg2);
14088
14089         wxPyEndAllowThreads(__tstate);
14090         if (PyErr_Occurred()) SWIG_fail;
14091     }
14092     Py_INCREF(Py_None); resultobj = Py_None;
14093     {
14094         if (temp2)
14095         delete arg2;
14096     }
14097     return resultobj;
14098     fail:
14099     {
14100         if (temp2)
14101         delete arg2;
14102     }
14103     return NULL;
14104 }
14105
14106
14107 static PyObject *_wrap_FileDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14108     PyObject *resultobj;
14109     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14110     wxString *arg2 = 0 ;
14111     bool temp2 = false ;
14112     PyObject * obj0 = 0 ;
14113     PyObject * obj1 = 0 ;
14114     char *kwnames[] = {
14115         (char *) "self",(char *) "path", NULL
14116     };
14117
14118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
14119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14120     if (SWIG_arg_fail(1)) SWIG_fail;
14121     {
14122         arg2 = wxString_in_helper(obj1);
14123         if (arg2 == NULL) SWIG_fail;
14124         temp2 = true;
14125     }
14126     {
14127         PyThreadState* __tstate = wxPyBeginAllowThreads();
14128         (arg1)->SetPath((wxString const &)*arg2);
14129
14130         wxPyEndAllowThreads(__tstate);
14131         if (PyErr_Occurred()) SWIG_fail;
14132     }
14133     Py_INCREF(Py_None); resultobj = Py_None;
14134     {
14135         if (temp2)
14136         delete arg2;
14137     }
14138     return resultobj;
14139     fail:
14140     {
14141         if (temp2)
14142         delete arg2;
14143     }
14144     return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_FileDialog_SetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14149     PyObject *resultobj;
14150     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14151     wxString *arg2 = 0 ;
14152     bool temp2 = false ;
14153     PyObject * obj0 = 0 ;
14154     PyObject * obj1 = 0 ;
14155     char *kwnames[] = {
14156         (char *) "self",(char *) "dir", NULL
14157     };
14158
14159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetDirectory",kwnames,&obj0,&obj1)) goto fail;
14160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14161     if (SWIG_arg_fail(1)) SWIG_fail;
14162     {
14163         arg2 = wxString_in_helper(obj1);
14164         if (arg2 == NULL) SWIG_fail;
14165         temp2 = true;
14166     }
14167     {
14168         PyThreadState* __tstate = wxPyBeginAllowThreads();
14169         (arg1)->SetDirectory((wxString const &)*arg2);
14170
14171         wxPyEndAllowThreads(__tstate);
14172         if (PyErr_Occurred()) SWIG_fail;
14173     }
14174     Py_INCREF(Py_None); resultobj = Py_None;
14175     {
14176         if (temp2)
14177         delete arg2;
14178     }
14179     return resultobj;
14180     fail:
14181     {
14182         if (temp2)
14183         delete arg2;
14184     }
14185     return NULL;
14186 }
14187
14188
14189 static PyObject *_wrap_FileDialog_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14190     PyObject *resultobj;
14191     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14192     wxString *arg2 = 0 ;
14193     bool temp2 = false ;
14194     PyObject * obj0 = 0 ;
14195     PyObject * obj1 = 0 ;
14196     char *kwnames[] = {
14197         (char *) "self",(char *) "name", NULL
14198     };
14199
14200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilename",kwnames,&obj0,&obj1)) goto fail;
14201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14202     if (SWIG_arg_fail(1)) SWIG_fail;
14203     {
14204         arg2 = wxString_in_helper(obj1);
14205         if (arg2 == NULL) SWIG_fail;
14206         temp2 = true;
14207     }
14208     {
14209         PyThreadState* __tstate = wxPyBeginAllowThreads();
14210         (arg1)->SetFilename((wxString const &)*arg2);
14211
14212         wxPyEndAllowThreads(__tstate);
14213         if (PyErr_Occurred()) SWIG_fail;
14214     }
14215     Py_INCREF(Py_None); resultobj = Py_None;
14216     {
14217         if (temp2)
14218         delete arg2;
14219     }
14220     return resultobj;
14221     fail:
14222     {
14223         if (temp2)
14224         delete arg2;
14225     }
14226     return NULL;
14227 }
14228
14229
14230 static PyObject *_wrap_FileDialog_SetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14231     PyObject *resultobj;
14232     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14233     wxString *arg2 = 0 ;
14234     bool temp2 = false ;
14235     PyObject * obj0 = 0 ;
14236     PyObject * obj1 = 0 ;
14237     char *kwnames[] = {
14238         (char *) "self",(char *) "wildCard", NULL
14239     };
14240
14241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetWildcard",kwnames,&obj0,&obj1)) goto fail;
14242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14243     if (SWIG_arg_fail(1)) SWIG_fail;
14244     {
14245         arg2 = wxString_in_helper(obj1);
14246         if (arg2 == NULL) SWIG_fail;
14247         temp2 = true;
14248     }
14249     {
14250         PyThreadState* __tstate = wxPyBeginAllowThreads();
14251         (arg1)->SetWildcard((wxString const &)*arg2);
14252
14253         wxPyEndAllowThreads(__tstate);
14254         if (PyErr_Occurred()) SWIG_fail;
14255     }
14256     Py_INCREF(Py_None); resultobj = Py_None;
14257     {
14258         if (temp2)
14259         delete arg2;
14260     }
14261     return resultobj;
14262     fail:
14263     {
14264         if (temp2)
14265         delete arg2;
14266     }
14267     return NULL;
14268 }
14269
14270
14271 static PyObject *_wrap_FileDialog_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14272     PyObject *resultobj;
14273     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14274     long arg2 ;
14275     PyObject * obj0 = 0 ;
14276     PyObject * obj1 = 0 ;
14277     char *kwnames[] = {
14278         (char *) "self",(char *) "style", NULL
14279     };
14280
14281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetStyle",kwnames,&obj0,&obj1)) goto fail;
14282     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14283     if (SWIG_arg_fail(1)) SWIG_fail;
14284     {
14285         arg2 = (long)(SWIG_As_long(obj1));
14286         if (SWIG_arg_fail(2)) SWIG_fail;
14287     }
14288     {
14289         PyThreadState* __tstate = wxPyBeginAllowThreads();
14290         (arg1)->SetStyle(arg2);
14291
14292         wxPyEndAllowThreads(__tstate);
14293         if (PyErr_Occurred()) SWIG_fail;
14294     }
14295     Py_INCREF(Py_None); resultobj = Py_None;
14296     return resultobj;
14297     fail:
14298     return NULL;
14299 }
14300
14301
14302 static PyObject *_wrap_FileDialog_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14303     PyObject *resultobj;
14304     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14305     int arg2 ;
14306     PyObject * obj0 = 0 ;
14307     PyObject * obj1 = 0 ;
14308     char *kwnames[] = {
14309         (char *) "self",(char *) "filterIndex", NULL
14310     };
14311
14312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
14313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14314     if (SWIG_arg_fail(1)) SWIG_fail;
14315     {
14316         arg2 = (int)(SWIG_As_int(obj1));
14317         if (SWIG_arg_fail(2)) SWIG_fail;
14318     }
14319     {
14320         PyThreadState* __tstate = wxPyBeginAllowThreads();
14321         (arg1)->SetFilterIndex(arg2);
14322
14323         wxPyEndAllowThreads(__tstate);
14324         if (PyErr_Occurred()) SWIG_fail;
14325     }
14326     Py_INCREF(Py_None); resultobj = Py_None;
14327     return resultobj;
14328     fail:
14329     return NULL;
14330 }
14331
14332
14333 static PyObject *_wrap_FileDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14334     PyObject *resultobj;
14335     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14336     wxString result;
14337     PyObject * obj0 = 0 ;
14338     char *kwnames[] = {
14339         (char *) "self", NULL
14340     };
14341
14342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetMessage",kwnames,&obj0)) goto fail;
14343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14344     if (SWIG_arg_fail(1)) SWIG_fail;
14345     {
14346         PyThreadState* __tstate = wxPyBeginAllowThreads();
14347         result = ((wxFileDialog const *)arg1)->GetMessage();
14348
14349         wxPyEndAllowThreads(__tstate);
14350         if (PyErr_Occurred()) SWIG_fail;
14351     }
14352     {
14353 #if wxUSE_UNICODE
14354         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14355 #else
14356         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14357 #endif
14358     }
14359     return resultobj;
14360     fail:
14361     return NULL;
14362 }
14363
14364
14365 static PyObject *_wrap_FileDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14366     PyObject *resultobj;
14367     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14368     wxString result;
14369     PyObject * obj0 = 0 ;
14370     char *kwnames[] = {
14371         (char *) "self", NULL
14372     };
14373
14374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPath",kwnames,&obj0)) goto fail;
14375     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14376     if (SWIG_arg_fail(1)) SWIG_fail;
14377     {
14378         PyThreadState* __tstate = wxPyBeginAllowThreads();
14379         result = ((wxFileDialog const *)arg1)->GetPath();
14380
14381         wxPyEndAllowThreads(__tstate);
14382         if (PyErr_Occurred()) SWIG_fail;
14383     }
14384     {
14385 #if wxUSE_UNICODE
14386         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14387 #else
14388         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14389 #endif
14390     }
14391     return resultobj;
14392     fail:
14393     return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_FileDialog_GetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14398     PyObject *resultobj;
14399     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14400     wxString result;
14401     PyObject * obj0 = 0 ;
14402     char *kwnames[] = {
14403         (char *) "self", NULL
14404     };
14405
14406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetDirectory",kwnames,&obj0)) goto fail;
14407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14408     if (SWIG_arg_fail(1)) SWIG_fail;
14409     {
14410         PyThreadState* __tstate = wxPyBeginAllowThreads();
14411         result = ((wxFileDialog const *)arg1)->GetDirectory();
14412
14413         wxPyEndAllowThreads(__tstate);
14414         if (PyErr_Occurred()) SWIG_fail;
14415     }
14416     {
14417 #if wxUSE_UNICODE
14418         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14419 #else
14420         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14421 #endif
14422     }
14423     return resultobj;
14424     fail:
14425     return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_FileDialog_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14430     PyObject *resultobj;
14431     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14432     wxString result;
14433     PyObject * obj0 = 0 ;
14434     char *kwnames[] = {
14435         (char *) "self", NULL
14436     };
14437
14438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilename",kwnames,&obj0)) goto fail;
14439     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14440     if (SWIG_arg_fail(1)) SWIG_fail;
14441     {
14442         PyThreadState* __tstate = wxPyBeginAllowThreads();
14443         result = ((wxFileDialog const *)arg1)->GetFilename();
14444
14445         wxPyEndAllowThreads(__tstate);
14446         if (PyErr_Occurred()) SWIG_fail;
14447     }
14448     {
14449 #if wxUSE_UNICODE
14450         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14451 #else
14452         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14453 #endif
14454     }
14455     return resultobj;
14456     fail:
14457     return NULL;
14458 }
14459
14460
14461 static PyObject *_wrap_FileDialog_GetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14462     PyObject *resultobj;
14463     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14464     wxString result;
14465     PyObject * obj0 = 0 ;
14466     char *kwnames[] = {
14467         (char *) "self", NULL
14468     };
14469
14470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetWildcard",kwnames,&obj0)) goto fail;
14471     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14472     if (SWIG_arg_fail(1)) SWIG_fail;
14473     {
14474         PyThreadState* __tstate = wxPyBeginAllowThreads();
14475         result = ((wxFileDialog const *)arg1)->GetWildcard();
14476
14477         wxPyEndAllowThreads(__tstate);
14478         if (PyErr_Occurred()) SWIG_fail;
14479     }
14480     {
14481 #if wxUSE_UNICODE
14482         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14483 #else
14484         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14485 #endif
14486     }
14487     return resultobj;
14488     fail:
14489     return NULL;
14490 }
14491
14492
14493 static PyObject *_wrap_FileDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14494     PyObject *resultobj;
14495     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14496     long result;
14497     PyObject * obj0 = 0 ;
14498     char *kwnames[] = {
14499         (char *) "self", NULL
14500     };
14501
14502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetStyle",kwnames,&obj0)) goto fail;
14503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14504     if (SWIG_arg_fail(1)) SWIG_fail;
14505     {
14506         PyThreadState* __tstate = wxPyBeginAllowThreads();
14507         result = (long)((wxFileDialog const *)arg1)->GetStyle();
14508
14509         wxPyEndAllowThreads(__tstate);
14510         if (PyErr_Occurred()) SWIG_fail;
14511     }
14512     {
14513         resultobj = SWIG_From_long((long)(result));
14514     }
14515     return resultobj;
14516     fail:
14517     return NULL;
14518 }
14519
14520
14521 static PyObject *_wrap_FileDialog_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14522     PyObject *resultobj;
14523     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14524     int result;
14525     PyObject * obj0 = 0 ;
14526     char *kwnames[] = {
14527         (char *) "self", NULL
14528     };
14529
14530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilterIndex",kwnames,&obj0)) goto fail;
14531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14532     if (SWIG_arg_fail(1)) SWIG_fail;
14533     {
14534         PyThreadState* __tstate = wxPyBeginAllowThreads();
14535         result = (int)((wxFileDialog const *)arg1)->GetFilterIndex();
14536
14537         wxPyEndAllowThreads(__tstate);
14538         if (PyErr_Occurred()) SWIG_fail;
14539     }
14540     {
14541         resultobj = SWIG_From_int((int)(result));
14542     }
14543     return resultobj;
14544     fail:
14545     return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_FileDialog_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
14550     PyObject *resultobj;
14551     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14552     PyObject *result;
14553     PyObject * obj0 = 0 ;
14554     char *kwnames[] = {
14555         (char *) "self", NULL
14556     };
14557
14558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilenames",kwnames,&obj0)) goto fail;
14559     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14560     if (SWIG_arg_fail(1)) SWIG_fail;
14561     {
14562         PyThreadState* __tstate = wxPyBeginAllowThreads();
14563         result = (PyObject *)wxFileDialog_GetFilenames(arg1);
14564
14565         wxPyEndAllowThreads(__tstate);
14566         if (PyErr_Occurred()) SWIG_fail;
14567     }
14568     resultobj = result;
14569     return resultobj;
14570     fail:
14571     return NULL;
14572 }
14573
14574
14575 static PyObject *_wrap_FileDialog_GetPaths(PyObject *, PyObject *args, PyObject *kwargs) {
14576     PyObject *resultobj;
14577     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14578     PyObject *result;
14579     PyObject * obj0 = 0 ;
14580     char *kwnames[] = {
14581         (char *) "self", NULL
14582     };
14583
14584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPaths",kwnames,&obj0)) goto fail;
14585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14586     if (SWIG_arg_fail(1)) SWIG_fail;
14587     {
14588         PyThreadState* __tstate = wxPyBeginAllowThreads();
14589         result = (PyObject *)wxFileDialog_GetPaths(arg1);
14590
14591         wxPyEndAllowThreads(__tstate);
14592         if (PyErr_Occurred()) SWIG_fail;
14593     }
14594     resultobj = result;
14595     return resultobj;
14596     fail:
14597     return NULL;
14598 }
14599
14600
14601 static PyObject * FileDialog_swigregister(PyObject *, PyObject *args) {
14602     PyObject *obj;
14603     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14604     SWIG_TypeClientData(SWIGTYPE_p_wxFileDialog, obj);
14605     Py_INCREF(obj);
14606     return Py_BuildValue((char *)"");
14607 }
14608 static PyObject *_wrap_new_MultiChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14609     PyObject *resultobj;
14610     wxWindow *arg1 = (wxWindow *) 0 ;
14611     wxString *arg2 = 0 ;
14612     wxString *arg3 = 0 ;
14613     int arg4 = (int) 0 ;
14614     wxString *arg5 = (wxString *) NULL ;
14615     long arg6 = (long) wxCHOICEDLG_STYLE ;
14616     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14617     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14618     wxMultiChoiceDialog *result;
14619     bool temp2 = false ;
14620     bool temp3 = false ;
14621     wxPoint temp7 ;
14622     PyObject * obj0 = 0 ;
14623     PyObject * obj1 = 0 ;
14624     PyObject * obj2 = 0 ;
14625     PyObject * obj3 = 0 ;
14626     PyObject * obj4 = 0 ;
14627     PyObject * obj5 = 0 ;
14628     char *kwnames[] = {
14629         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14630     };
14631
14632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_MultiChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14633     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14634     if (SWIG_arg_fail(1)) SWIG_fail;
14635     {
14636         arg2 = wxString_in_helper(obj1);
14637         if (arg2 == NULL) SWIG_fail;
14638         temp2 = true;
14639     }
14640     {
14641         arg3 = wxString_in_helper(obj2);
14642         if (arg3 == NULL) SWIG_fail;
14643         temp3 = true;
14644     }
14645     if (obj3) {
14646         {
14647             arg4 = PyList_Size(obj3);
14648             arg5 = wxString_LIST_helper(obj3);
14649             if (arg5 == NULL) SWIG_fail;
14650         }
14651     }
14652     if (obj4) {
14653         {
14654             arg6 = (long)(SWIG_As_long(obj4));
14655             if (SWIG_arg_fail(6)) SWIG_fail;
14656         }
14657     }
14658     if (obj5) {
14659         {
14660             arg7 = &temp7;
14661             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14662         }
14663     }
14664     {
14665         if (!wxPyCheckForApp()) SWIG_fail;
14666         PyThreadState* __tstate = wxPyBeginAllowThreads();
14667         result = (wxMultiChoiceDialog *)new wxMultiChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14668
14669         wxPyEndAllowThreads(__tstate);
14670         if (PyErr_Occurred()) SWIG_fail;
14671     }
14672     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMultiChoiceDialog, 1);
14673     {
14674         if (temp2)
14675         delete arg2;
14676     }
14677     {
14678         if (temp3)
14679         delete arg3;
14680     }
14681     {
14682         if (arg5) delete [] arg5;
14683     }
14684     return resultobj;
14685     fail:
14686     {
14687         if (temp2)
14688         delete arg2;
14689     }
14690     {
14691         if (temp3)
14692         delete arg3;
14693     }
14694     {
14695         if (arg5) delete [] arg5;
14696     }
14697     return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_MultiChoiceDialog_SetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14702     PyObject *resultobj;
14703     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14704     wxArrayInt *arg2 = 0 ;
14705     bool temp2 = false ;
14706     PyObject * obj0 = 0 ;
14707     PyObject * obj1 = 0 ;
14708     char *kwnames[] = {
14709         (char *) "self",(char *) "selections", NULL
14710     };
14711
14712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MultiChoiceDialog_SetSelections",kwnames,&obj0,&obj1)) goto fail;
14713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14714     if (SWIG_arg_fail(1)) SWIG_fail;
14715     {
14716         if (! PySequence_Check(obj1)) {
14717             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
14718             SWIG_fail;
14719         }
14720         arg2 = new wxArrayInt;
14721         temp2 = true;
14722         int i, len=PySequence_Length(obj1);
14723         for (i=0; i<len; i++) {
14724             PyObject* item = PySequence_GetItem(obj1, i);
14725             PyObject* number  = PyNumber_Int(item);
14726             arg2->Add(PyInt_AS_LONG(number));
14727             Py_DECREF(item);
14728             Py_DECREF(number);
14729         }
14730     }
14731     {
14732         PyThreadState* __tstate = wxPyBeginAllowThreads();
14733         (arg1)->SetSelections((wxArrayInt const &)*arg2);
14734
14735         wxPyEndAllowThreads(__tstate);
14736         if (PyErr_Occurred()) SWIG_fail;
14737     }
14738     Py_INCREF(Py_None); resultobj = Py_None;
14739     {
14740         if (temp2) delete arg2;
14741     }
14742     return resultobj;
14743     fail:
14744     {
14745         if (temp2) delete arg2;
14746     }
14747     return NULL;
14748 }
14749
14750
14751 static PyObject *_wrap_MultiChoiceDialog_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14752     PyObject *resultobj;
14753     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14754     PyObject *result;
14755     PyObject * obj0 = 0 ;
14756     char *kwnames[] = {
14757         (char *) "self", NULL
14758     };
14759
14760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MultiChoiceDialog_GetSelections",kwnames,&obj0)) goto fail;
14761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14762     if (SWIG_arg_fail(1)) SWIG_fail;
14763     {
14764         PyThreadState* __tstate = wxPyBeginAllowThreads();
14765         result = (PyObject *)wxMultiChoiceDialog_GetSelections(arg1);
14766
14767         wxPyEndAllowThreads(__tstate);
14768         if (PyErr_Occurred()) SWIG_fail;
14769     }
14770     resultobj = result;
14771     return resultobj;
14772     fail:
14773     return NULL;
14774 }
14775
14776
14777 static PyObject * MultiChoiceDialog_swigregister(PyObject *, PyObject *args) {
14778     PyObject *obj;
14779     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14780     SWIG_TypeClientData(SWIGTYPE_p_wxMultiChoiceDialog, obj);
14781     Py_INCREF(obj);
14782     return Py_BuildValue((char *)"");
14783 }
14784 static PyObject *_wrap_new_SingleChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14785     PyObject *resultobj;
14786     wxWindow *arg1 = (wxWindow *) 0 ;
14787     wxString *arg2 = 0 ;
14788     wxString *arg3 = 0 ;
14789     int arg4 ;
14790     wxString *arg5 = (wxString *) 0 ;
14791     long arg6 = (long) wxCHOICEDLG_STYLE ;
14792     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14793     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14794     wxSingleChoiceDialog *result;
14795     bool temp2 = false ;
14796     bool temp3 = false ;
14797     wxPoint temp7 ;
14798     PyObject * obj0 = 0 ;
14799     PyObject * obj1 = 0 ;
14800     PyObject * obj2 = 0 ;
14801     PyObject * obj3 = 0 ;
14802     PyObject * obj4 = 0 ;
14803     PyObject * obj5 = 0 ;
14804     char *kwnames[] = {
14805         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14806     };
14807
14808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:new_SingleChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14810     if (SWIG_arg_fail(1)) SWIG_fail;
14811     {
14812         arg2 = wxString_in_helper(obj1);
14813         if (arg2 == NULL) SWIG_fail;
14814         temp2 = true;
14815     }
14816     {
14817         arg3 = wxString_in_helper(obj2);
14818         if (arg3 == NULL) SWIG_fail;
14819         temp3 = true;
14820     }
14821     {
14822         arg4 = PyList_Size(obj3);
14823         arg5 = wxString_LIST_helper(obj3);
14824         if (arg5 == NULL) SWIG_fail;
14825     }
14826     if (obj4) {
14827         {
14828             arg6 = (long)(SWIG_As_long(obj4));
14829             if (SWIG_arg_fail(6)) SWIG_fail;
14830         }
14831     }
14832     if (obj5) {
14833         {
14834             arg7 = &temp7;
14835             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14836         }
14837     }
14838     {
14839         if (!wxPyCheckForApp()) SWIG_fail;
14840         PyThreadState* __tstate = wxPyBeginAllowThreads();
14841         result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14842
14843         wxPyEndAllowThreads(__tstate);
14844         if (PyErr_Occurred()) SWIG_fail;
14845     }
14846     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleChoiceDialog, 1);
14847     {
14848         if (temp2)
14849         delete arg2;
14850     }
14851     {
14852         if (temp3)
14853         delete arg3;
14854     }
14855     {
14856         if (arg5) delete [] arg5;
14857     }
14858     return resultobj;
14859     fail:
14860     {
14861         if (temp2)
14862         delete arg2;
14863     }
14864     {
14865         if (temp3)
14866         delete arg3;
14867     }
14868     {
14869         if (arg5) delete [] arg5;
14870     }
14871     return NULL;
14872 }
14873
14874
14875 static PyObject *_wrap_SingleChoiceDialog_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14876     PyObject *resultobj;
14877     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14878     int result;
14879     PyObject * obj0 = 0 ;
14880     char *kwnames[] = {
14881         (char *) "self", NULL
14882     };
14883
14884     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetSelection",kwnames,&obj0)) goto fail;
14885     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14886     if (SWIG_arg_fail(1)) SWIG_fail;
14887     {
14888         PyThreadState* __tstate = wxPyBeginAllowThreads();
14889         result = (int)(arg1)->GetSelection();
14890
14891         wxPyEndAllowThreads(__tstate);
14892         if (PyErr_Occurred()) SWIG_fail;
14893     }
14894     {
14895         resultobj = SWIG_From_int((int)(result));
14896     }
14897     return resultobj;
14898     fail:
14899     return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_SingleChoiceDialog_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14904     PyObject *resultobj;
14905     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14906     wxString result;
14907     PyObject * obj0 = 0 ;
14908     char *kwnames[] = {
14909         (char *) "self", NULL
14910     };
14911
14912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetStringSelection",kwnames,&obj0)) goto fail;
14913     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14914     if (SWIG_arg_fail(1)) SWIG_fail;
14915     {
14916         PyThreadState* __tstate = wxPyBeginAllowThreads();
14917         result = (arg1)->GetStringSelection();
14918
14919         wxPyEndAllowThreads(__tstate);
14920         if (PyErr_Occurred()) SWIG_fail;
14921     }
14922     {
14923 #if wxUSE_UNICODE
14924         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14925 #else
14926         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14927 #endif
14928     }
14929     return resultobj;
14930     fail:
14931     return NULL;
14932 }
14933
14934
14935 static PyObject *_wrap_SingleChoiceDialog_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14936     PyObject *resultobj;
14937     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14938     int arg2 ;
14939     PyObject * obj0 = 0 ;
14940     PyObject * obj1 = 0 ;
14941     char *kwnames[] = {
14942         (char *) "self",(char *) "sel", NULL
14943     };
14944
14945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SingleChoiceDialog_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14947     if (SWIG_arg_fail(1)) SWIG_fail;
14948     {
14949         arg2 = (int)(SWIG_As_int(obj1));
14950         if (SWIG_arg_fail(2)) SWIG_fail;
14951     }
14952     {
14953         PyThreadState* __tstate = wxPyBeginAllowThreads();
14954         (arg1)->SetSelection(arg2);
14955
14956         wxPyEndAllowThreads(__tstate);
14957         if (PyErr_Occurred()) SWIG_fail;
14958     }
14959     Py_INCREF(Py_None); resultobj = Py_None;
14960     return resultobj;
14961     fail:
14962     return NULL;
14963 }
14964
14965
14966 static PyObject * SingleChoiceDialog_swigregister(PyObject *, PyObject *args) {
14967     PyObject *obj;
14968     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969     SWIG_TypeClientData(SWIGTYPE_p_wxSingleChoiceDialog, obj);
14970     Py_INCREF(obj);
14971     return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_new_TextEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14974     PyObject *resultobj;
14975     wxWindow *arg1 = (wxWindow *) 0 ;
14976     wxString *arg2 = 0 ;
14977     wxString const &arg3_defvalue = wxPyGetTextFromUserPromptStr ;
14978     wxString *arg3 = (wxString *) &arg3_defvalue ;
14979     wxString const &arg4_defvalue = wxPyEmptyString ;
14980     wxString *arg4 = (wxString *) &arg4_defvalue ;
14981     long arg5 = (long) wxTextEntryDialogStyle ;
14982     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14983     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14984     wxTextEntryDialog *result;
14985     bool temp2 = false ;
14986     bool temp3 = false ;
14987     bool temp4 = false ;
14988     wxPoint temp6 ;
14989     PyObject * obj0 = 0 ;
14990     PyObject * obj1 = 0 ;
14991     PyObject * obj2 = 0 ;
14992     PyObject * obj3 = 0 ;
14993     PyObject * obj4 = 0 ;
14994     PyObject * obj5 = 0 ;
14995     char *kwnames[] = {
14996         (char *) "parent",(char *) "message",(char *) "caption",(char *) "defaultValue",(char *) "style",(char *) "pos", NULL
14997     };
14998
14999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_TextEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15001     if (SWIG_arg_fail(1)) SWIG_fail;
15002     {
15003         arg2 = wxString_in_helper(obj1);
15004         if (arg2 == NULL) SWIG_fail;
15005         temp2 = true;
15006     }
15007     if (obj2) {
15008         {
15009             arg3 = wxString_in_helper(obj2);
15010             if (arg3 == NULL) SWIG_fail;
15011             temp3 = true;
15012         }
15013     }
15014     if (obj3) {
15015         {
15016             arg4 = wxString_in_helper(obj3);
15017             if (arg4 == NULL) SWIG_fail;
15018             temp4 = true;
15019         }
15020     }
15021     if (obj4) {
15022         {
15023             arg5 = (long)(SWIG_As_long(obj4));
15024             if (SWIG_arg_fail(5)) SWIG_fail;
15025         }
15026     }
15027     if (obj5) {
15028         {
15029             arg6 = &temp6;
15030             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15031         }
15032     }
15033     {
15034         if (!wxPyCheckForApp()) SWIG_fail;
15035         PyThreadState* __tstate = wxPyBeginAllowThreads();
15036         result = (wxTextEntryDialog *)new wxTextEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15037
15038         wxPyEndAllowThreads(__tstate);
15039         if (PyErr_Occurred()) SWIG_fail;
15040     }
15041     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextEntryDialog, 1);
15042     {
15043         if (temp2)
15044         delete arg2;
15045     }
15046     {
15047         if (temp3)
15048         delete arg3;
15049     }
15050     {
15051         if (temp4)
15052         delete arg4;
15053     }
15054     return resultobj;
15055     fail:
15056     {
15057         if (temp2)
15058         delete arg2;
15059     }
15060     {
15061         if (temp3)
15062         delete arg3;
15063     }
15064     {
15065         if (temp4)
15066         delete arg4;
15067     }
15068     return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_TextEntryDialog_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15073     PyObject *resultobj;
15074     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15075     wxString result;
15076     PyObject * obj0 = 0 ;
15077     char *kwnames[] = {
15078         (char *) "self", NULL
15079     };
15080
15081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextEntryDialog_GetValue",kwnames,&obj0)) goto fail;
15082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15083     if (SWIG_arg_fail(1)) SWIG_fail;
15084     {
15085         PyThreadState* __tstate = wxPyBeginAllowThreads();
15086         result = (arg1)->GetValue();
15087
15088         wxPyEndAllowThreads(__tstate);
15089         if (PyErr_Occurred()) SWIG_fail;
15090     }
15091     {
15092 #if wxUSE_UNICODE
15093         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15094 #else
15095         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15096 #endif
15097     }
15098     return resultobj;
15099     fail:
15100     return NULL;
15101 }
15102
15103
15104 static PyObject *_wrap_TextEntryDialog_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15105     PyObject *resultobj;
15106     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15107     wxString *arg2 = 0 ;
15108     bool temp2 = false ;
15109     PyObject * obj0 = 0 ;
15110     PyObject * obj1 = 0 ;
15111     char *kwnames[] = {
15112         (char *) "self",(char *) "value", NULL
15113     };
15114
15115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextEntryDialog_SetValue",kwnames,&obj0,&obj1)) goto fail;
15116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15117     if (SWIG_arg_fail(1)) SWIG_fail;
15118     {
15119         arg2 = wxString_in_helper(obj1);
15120         if (arg2 == NULL) SWIG_fail;
15121         temp2 = true;
15122     }
15123     {
15124         PyThreadState* __tstate = wxPyBeginAllowThreads();
15125         (arg1)->SetValue((wxString const &)*arg2);
15126
15127         wxPyEndAllowThreads(__tstate);
15128         if (PyErr_Occurred()) SWIG_fail;
15129     }
15130     Py_INCREF(Py_None); resultobj = Py_None;
15131     {
15132         if (temp2)
15133         delete arg2;
15134     }
15135     return resultobj;
15136     fail:
15137     {
15138         if (temp2)
15139         delete arg2;
15140     }
15141     return NULL;
15142 }
15143
15144
15145 static PyObject * TextEntryDialog_swigregister(PyObject *, PyObject *args) {
15146     PyObject *obj;
15147     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15148     SWIG_TypeClientData(SWIGTYPE_p_wxTextEntryDialog, obj);
15149     Py_INCREF(obj);
15150     return Py_BuildValue((char *)"");
15151 }
15152 static int _wrap_GetPasswordFromUserPromptStr_set(PyObject *) {
15153     PyErr_SetString(PyExc_TypeError,"Variable GetPasswordFromUserPromptStr is read-only.");
15154     return 1;
15155 }
15156
15157
15158 static PyObject *_wrap_GetPasswordFromUserPromptStr_get(void) {
15159     PyObject *pyobj;
15160
15161     {
15162 #if wxUSE_UNICODE
15163         pyobj = PyUnicode_FromWideChar((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15164 #else
15165         pyobj = PyString_FromStringAndSize((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15166 #endif
15167     }
15168     return pyobj;
15169 }
15170
15171
15172 static PyObject *_wrap_new_PasswordEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15173     PyObject *resultobj;
15174     wxWindow *arg1 = (wxWindow *) 0 ;
15175     wxString *arg2 = 0 ;
15176     wxString const &arg3_defvalue = wxPyGetPasswordFromUserPromptStr ;
15177     wxString *arg3 = (wxString *) &arg3_defvalue ;
15178     wxString const &arg4_defvalue = wxPyEmptyString ;
15179     wxString *arg4 = (wxString *) &arg4_defvalue ;
15180     long arg5 = (long) wxTextEntryDialogStyle ;
15181     wxPoint const &arg6_defvalue = wxDefaultPosition ;
15182     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
15183     wxPasswordEntryDialog *result;
15184     bool temp2 = false ;
15185     bool temp3 = false ;
15186     bool temp4 = false ;
15187     wxPoint temp6 ;
15188     PyObject * obj0 = 0 ;
15189     PyObject * obj1 = 0 ;
15190     PyObject * obj2 = 0 ;
15191     PyObject * obj3 = 0 ;
15192     PyObject * obj4 = 0 ;
15193     PyObject * obj5 = 0 ;
15194     char *kwnames[] = {
15195         (char *) "parent",(char *) "message",(char *) "caption",(char *) "value",(char *) "style",(char *) "pos", NULL
15196     };
15197
15198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PasswordEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15199     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15200     if (SWIG_arg_fail(1)) SWIG_fail;
15201     {
15202         arg2 = wxString_in_helper(obj1);
15203         if (arg2 == NULL) SWIG_fail;
15204         temp2 = true;
15205     }
15206     if (obj2) {
15207         {
15208             arg3 = wxString_in_helper(obj2);
15209             if (arg3 == NULL) SWIG_fail;
15210             temp3 = true;
15211         }
15212     }
15213     if (obj3) {
15214         {
15215             arg4 = wxString_in_helper(obj3);
15216             if (arg4 == NULL) SWIG_fail;
15217             temp4 = true;
15218         }
15219     }
15220     if (obj4) {
15221         {
15222             arg5 = (long)(SWIG_As_long(obj4));
15223             if (SWIG_arg_fail(5)) SWIG_fail;
15224         }
15225     }
15226     if (obj5) {
15227         {
15228             arg6 = &temp6;
15229             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15230         }
15231     }
15232     {
15233         PyThreadState* __tstate = wxPyBeginAllowThreads();
15234         result = (wxPasswordEntryDialog *)new wxPasswordEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15235
15236         wxPyEndAllowThreads(__tstate);
15237         if (PyErr_Occurred()) SWIG_fail;
15238     }
15239     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPasswordEntryDialog, 1);
15240     {
15241         if (temp2)
15242         delete arg2;
15243     }
15244     {
15245         if (temp3)
15246         delete arg3;
15247     }
15248     {
15249         if (temp4)
15250         delete arg4;
15251     }
15252     return resultobj;
15253     fail:
15254     {
15255         if (temp2)
15256         delete arg2;
15257     }
15258     {
15259         if (temp3)
15260         delete arg3;
15261     }
15262     {
15263         if (temp4)
15264         delete arg4;
15265     }
15266     return NULL;
15267 }
15268
15269
15270 static PyObject * PasswordEntryDialog_swigregister(PyObject *, PyObject *args) {
15271     PyObject *obj;
15272     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15273     SWIG_TypeClientData(SWIGTYPE_p_wxPasswordEntryDialog, obj);
15274     Py_INCREF(obj);
15275     return Py_BuildValue((char *)"");
15276 }
15277 static PyObject *_wrap_new_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15278     PyObject *resultobj;
15279     wxFontData *result;
15280     char *kwnames[] = {
15281         NULL
15282     };
15283
15284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontData",kwnames)) goto fail;
15285     {
15286         PyThreadState* __tstate = wxPyBeginAllowThreads();
15287         result = (wxFontData *)new wxFontData();
15288
15289         wxPyEndAllowThreads(__tstate);
15290         if (PyErr_Occurred()) SWIG_fail;
15291     }
15292     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 1);
15293     return resultobj;
15294     fail:
15295     return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_delete_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15300     PyObject *resultobj;
15301     wxFontData *arg1 = (wxFontData *) 0 ;
15302     PyObject * obj0 = 0 ;
15303     char *kwnames[] = {
15304         (char *) "self", NULL
15305     };
15306
15307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontData",kwnames,&obj0)) goto fail;
15308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15309     if (SWIG_arg_fail(1)) SWIG_fail;
15310     {
15311         PyThreadState* __tstate = wxPyBeginAllowThreads();
15312         delete arg1;
15313
15314         wxPyEndAllowThreads(__tstate);
15315         if (PyErr_Occurred()) SWIG_fail;
15316     }
15317     Py_INCREF(Py_None); resultobj = Py_None;
15318     return resultobj;
15319     fail:
15320     return NULL;
15321 }
15322
15323
15324 static PyObject *_wrap_FontData_EnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15325     PyObject *resultobj;
15326     wxFontData *arg1 = (wxFontData *) 0 ;
15327     bool arg2 ;
15328     PyObject * obj0 = 0 ;
15329     PyObject * obj1 = 0 ;
15330     char *kwnames[] = {
15331         (char *) "self",(char *) "enable", NULL
15332     };
15333
15334     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_EnableEffects",kwnames,&obj0,&obj1)) goto fail;
15335     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15336     if (SWIG_arg_fail(1)) SWIG_fail;
15337     {
15338         arg2 = (bool)(SWIG_As_bool(obj1));
15339         if (SWIG_arg_fail(2)) SWIG_fail;
15340     }
15341     {
15342         PyThreadState* __tstate = wxPyBeginAllowThreads();
15343         (arg1)->EnableEffects(arg2);
15344
15345         wxPyEndAllowThreads(__tstate);
15346         if (PyErr_Occurred()) SWIG_fail;
15347     }
15348     Py_INCREF(Py_None); resultobj = Py_None;
15349     return resultobj;
15350     fail:
15351     return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_FontData_GetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15356     PyObject *resultobj;
15357     wxFontData *arg1 = (wxFontData *) 0 ;
15358     bool result;
15359     PyObject * obj0 = 0 ;
15360     char *kwnames[] = {
15361         (char *) "self", NULL
15362     };
15363
15364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetAllowSymbols",kwnames,&obj0)) goto fail;
15365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15366     if (SWIG_arg_fail(1)) SWIG_fail;
15367     {
15368         PyThreadState* __tstate = wxPyBeginAllowThreads();
15369         result = (bool)(arg1)->GetAllowSymbols();
15370
15371         wxPyEndAllowThreads(__tstate);
15372         if (PyErr_Occurred()) SWIG_fail;
15373     }
15374     {
15375         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15376     }
15377     return resultobj;
15378     fail:
15379     return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_FontData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15384     PyObject *resultobj;
15385     wxFontData *arg1 = (wxFontData *) 0 ;
15386     wxColour result;
15387     PyObject * obj0 = 0 ;
15388     char *kwnames[] = {
15389         (char *) "self", NULL
15390     };
15391
15392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetColour",kwnames,&obj0)) goto fail;
15393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15394     if (SWIG_arg_fail(1)) SWIG_fail;
15395     {
15396         PyThreadState* __tstate = wxPyBeginAllowThreads();
15397         result = (arg1)->GetColour();
15398
15399         wxPyEndAllowThreads(__tstate);
15400         if (PyErr_Occurred()) SWIG_fail;
15401     }
15402     {
15403         wxColour * resultptr;
15404         resultptr = new wxColour((wxColour &)(result));
15405         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15406     }
15407     return resultobj;
15408     fail:
15409     return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_FontData_GetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15414     PyObject *resultobj;
15415     wxFontData *arg1 = (wxFontData *) 0 ;
15416     wxFont result;
15417     PyObject * obj0 = 0 ;
15418     char *kwnames[] = {
15419         (char *) "self", NULL
15420     };
15421
15422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetChosenFont",kwnames,&obj0)) goto fail;
15423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15424     if (SWIG_arg_fail(1)) SWIG_fail;
15425     {
15426         PyThreadState* __tstate = wxPyBeginAllowThreads();
15427         result = (arg1)->GetChosenFont();
15428
15429         wxPyEndAllowThreads(__tstate);
15430         if (PyErr_Occurred()) SWIG_fail;
15431     }
15432     {
15433         wxFont * resultptr;
15434         resultptr = new wxFont((wxFont &)(result));
15435         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15436     }
15437     return resultobj;
15438     fail:
15439     return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_FontData_GetEnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15444     PyObject *resultobj;
15445     wxFontData *arg1 = (wxFontData *) 0 ;
15446     bool result;
15447     PyObject * obj0 = 0 ;
15448     char *kwnames[] = {
15449         (char *) "self", NULL
15450     };
15451
15452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetEnableEffects",kwnames,&obj0)) goto fail;
15453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15454     if (SWIG_arg_fail(1)) SWIG_fail;
15455     {
15456         PyThreadState* __tstate = wxPyBeginAllowThreads();
15457         result = (bool)(arg1)->GetEnableEffects();
15458
15459         wxPyEndAllowThreads(__tstate);
15460         if (PyErr_Occurred()) SWIG_fail;
15461     }
15462     {
15463         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15464     }
15465     return resultobj;
15466     fail:
15467     return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_FontData_GetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15472     PyObject *resultobj;
15473     wxFontData *arg1 = (wxFontData *) 0 ;
15474     wxFont result;
15475     PyObject * obj0 = 0 ;
15476     char *kwnames[] = {
15477         (char *) "self", NULL
15478     };
15479
15480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetInitialFont",kwnames,&obj0)) goto fail;
15481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15482     if (SWIG_arg_fail(1)) SWIG_fail;
15483     {
15484         PyThreadState* __tstate = wxPyBeginAllowThreads();
15485         result = (arg1)->GetInitialFont();
15486
15487         wxPyEndAllowThreads(__tstate);
15488         if (PyErr_Occurred()) SWIG_fail;
15489     }
15490     {
15491         wxFont * resultptr;
15492         resultptr = new wxFont((wxFont &)(result));
15493         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15494     }
15495     return resultobj;
15496     fail:
15497     return NULL;
15498 }
15499
15500
15501 static PyObject *_wrap_FontData_GetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15502     PyObject *resultobj;
15503     wxFontData *arg1 = (wxFontData *) 0 ;
15504     bool result;
15505     PyObject * obj0 = 0 ;
15506     char *kwnames[] = {
15507         (char *) "self", NULL
15508     };
15509
15510     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetShowHelp",kwnames,&obj0)) goto fail;
15511     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15512     if (SWIG_arg_fail(1)) SWIG_fail;
15513     {
15514         PyThreadState* __tstate = wxPyBeginAllowThreads();
15515         result = (bool)(arg1)->GetShowHelp();
15516
15517         wxPyEndAllowThreads(__tstate);
15518         if (PyErr_Occurred()) SWIG_fail;
15519     }
15520     {
15521         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15522     }
15523     return resultobj;
15524     fail:
15525     return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_FontData_SetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15530     PyObject *resultobj;
15531     wxFontData *arg1 = (wxFontData *) 0 ;
15532     bool arg2 ;
15533     PyObject * obj0 = 0 ;
15534     PyObject * obj1 = 0 ;
15535     char *kwnames[] = {
15536         (char *) "self",(char *) "allowSymbols", NULL
15537     };
15538
15539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetAllowSymbols",kwnames,&obj0,&obj1)) goto fail;
15540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15541     if (SWIG_arg_fail(1)) SWIG_fail;
15542     {
15543         arg2 = (bool)(SWIG_As_bool(obj1));
15544         if (SWIG_arg_fail(2)) SWIG_fail;
15545     }
15546     {
15547         PyThreadState* __tstate = wxPyBeginAllowThreads();
15548         (arg1)->SetAllowSymbols(arg2);
15549
15550         wxPyEndAllowThreads(__tstate);
15551         if (PyErr_Occurred()) SWIG_fail;
15552     }
15553     Py_INCREF(Py_None); resultobj = Py_None;
15554     return resultobj;
15555     fail:
15556     return NULL;
15557 }
15558
15559
15560 static PyObject *_wrap_FontData_SetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15561     PyObject *resultobj;
15562     wxFontData *arg1 = (wxFontData *) 0 ;
15563     wxFont *arg2 = 0 ;
15564     PyObject * obj0 = 0 ;
15565     PyObject * obj1 = 0 ;
15566     char *kwnames[] = {
15567         (char *) "self",(char *) "font", NULL
15568     };
15569
15570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetChosenFont",kwnames,&obj0,&obj1)) goto fail;
15571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15572     if (SWIG_arg_fail(1)) SWIG_fail;
15573     {
15574         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15575         if (SWIG_arg_fail(2)) SWIG_fail;
15576         if (arg2 == NULL) {
15577             SWIG_null_ref("wxFont");
15578         }
15579         if (SWIG_arg_fail(2)) SWIG_fail;
15580     }
15581     {
15582         PyThreadState* __tstate = wxPyBeginAllowThreads();
15583         (arg1)->SetChosenFont((wxFont const &)*arg2);
15584
15585         wxPyEndAllowThreads(__tstate);
15586         if (PyErr_Occurred()) SWIG_fail;
15587     }
15588     Py_INCREF(Py_None); resultobj = Py_None;
15589     return resultobj;
15590     fail:
15591     return NULL;
15592 }
15593
15594
15595 static PyObject *_wrap_FontData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15596     PyObject *resultobj;
15597     wxFontData *arg1 = (wxFontData *) 0 ;
15598     wxColour *arg2 = 0 ;
15599     wxColour temp2 ;
15600     PyObject * obj0 = 0 ;
15601     PyObject * obj1 = 0 ;
15602     char *kwnames[] = {
15603         (char *) "self",(char *) "colour", NULL
15604     };
15605
15606     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetColour",kwnames,&obj0,&obj1)) goto fail;
15607     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15608     if (SWIG_arg_fail(1)) SWIG_fail;
15609     {
15610         arg2 = &temp2;
15611         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15612     }
15613     {
15614         PyThreadState* __tstate = wxPyBeginAllowThreads();
15615         (arg1)->SetColour((wxColour const &)*arg2);
15616
15617         wxPyEndAllowThreads(__tstate);
15618         if (PyErr_Occurred()) SWIG_fail;
15619     }
15620     Py_INCREF(Py_None); resultobj = Py_None;
15621     return resultobj;
15622     fail:
15623     return NULL;
15624 }
15625
15626
15627 static PyObject *_wrap_FontData_SetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15628     PyObject *resultobj;
15629     wxFontData *arg1 = (wxFontData *) 0 ;
15630     wxFont *arg2 = 0 ;
15631     PyObject * obj0 = 0 ;
15632     PyObject * obj1 = 0 ;
15633     char *kwnames[] = {
15634         (char *) "self",(char *) "font", NULL
15635     };
15636
15637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetInitialFont",kwnames,&obj0,&obj1)) goto fail;
15638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15639     if (SWIG_arg_fail(1)) SWIG_fail;
15640     {
15641         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15642         if (SWIG_arg_fail(2)) SWIG_fail;
15643         if (arg2 == NULL) {
15644             SWIG_null_ref("wxFont");
15645         }
15646         if (SWIG_arg_fail(2)) SWIG_fail;
15647     }
15648     {
15649         PyThreadState* __tstate = wxPyBeginAllowThreads();
15650         (arg1)->SetInitialFont((wxFont const &)*arg2);
15651
15652         wxPyEndAllowThreads(__tstate);
15653         if (PyErr_Occurred()) SWIG_fail;
15654     }
15655     Py_INCREF(Py_None); resultobj = Py_None;
15656     return resultobj;
15657     fail:
15658     return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_FontData_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15663     PyObject *resultobj;
15664     wxFontData *arg1 = (wxFontData *) 0 ;
15665     int arg2 ;
15666     int arg3 ;
15667     PyObject * obj0 = 0 ;
15668     PyObject * obj1 = 0 ;
15669     PyObject * obj2 = 0 ;
15670     char *kwnames[] = {
15671         (char *) "self",(char *) "min",(char *) "max", NULL
15672     };
15673
15674     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FontData_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15675     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15676     if (SWIG_arg_fail(1)) SWIG_fail;
15677     {
15678         arg2 = (int)(SWIG_As_int(obj1));
15679         if (SWIG_arg_fail(2)) SWIG_fail;
15680     }
15681     {
15682         arg3 = (int)(SWIG_As_int(obj2));
15683         if (SWIG_arg_fail(3)) SWIG_fail;
15684     }
15685     {
15686         PyThreadState* __tstate = wxPyBeginAllowThreads();
15687         (arg1)->SetRange(arg2,arg3);
15688
15689         wxPyEndAllowThreads(__tstate);
15690         if (PyErr_Occurred()) SWIG_fail;
15691     }
15692     Py_INCREF(Py_None); resultobj = Py_None;
15693     return resultobj;
15694     fail:
15695     return NULL;
15696 }
15697
15698
15699 static PyObject *_wrap_FontData_SetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15700     PyObject *resultobj;
15701     wxFontData *arg1 = (wxFontData *) 0 ;
15702     bool arg2 ;
15703     PyObject * obj0 = 0 ;
15704     PyObject * obj1 = 0 ;
15705     char *kwnames[] = {
15706         (char *) "self",(char *) "showHelp", NULL
15707     };
15708
15709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetShowHelp",kwnames,&obj0,&obj1)) goto fail;
15710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15711     if (SWIG_arg_fail(1)) SWIG_fail;
15712     {
15713         arg2 = (bool)(SWIG_As_bool(obj1));
15714         if (SWIG_arg_fail(2)) SWIG_fail;
15715     }
15716     {
15717         PyThreadState* __tstate = wxPyBeginAllowThreads();
15718         (arg1)->SetShowHelp(arg2);
15719
15720         wxPyEndAllowThreads(__tstate);
15721         if (PyErr_Occurred()) SWIG_fail;
15722     }
15723     Py_INCREF(Py_None); resultobj = Py_None;
15724     return resultobj;
15725     fail:
15726     return NULL;
15727 }
15728
15729
15730 static PyObject * FontData_swigregister(PyObject *, PyObject *args) {
15731     PyObject *obj;
15732     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15733     SWIG_TypeClientData(SWIGTYPE_p_wxFontData, obj);
15734     Py_INCREF(obj);
15735     return Py_BuildValue((char *)"");
15736 }
15737 static PyObject *_wrap_new_FontDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15738     PyObject *resultobj;
15739     wxWindow *arg1 = (wxWindow *) 0 ;
15740     wxFontData *arg2 = 0 ;
15741     wxFontDialog *result;
15742     PyObject * obj0 = 0 ;
15743     PyObject * obj1 = 0 ;
15744     char *kwnames[] = {
15745         (char *) "parent",(char *) "data", NULL
15746     };
15747
15748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_FontDialog",kwnames,&obj0,&obj1)) goto fail;
15749     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15750     if (SWIG_arg_fail(1)) SWIG_fail;
15751     {
15752         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15753         if (SWIG_arg_fail(2)) SWIG_fail;
15754         if (arg2 == NULL) {
15755             SWIG_null_ref("wxFontData");
15756         }
15757         if (SWIG_arg_fail(2)) SWIG_fail;
15758     }
15759     {
15760         if (!wxPyCheckForApp()) SWIG_fail;
15761         PyThreadState* __tstate = wxPyBeginAllowThreads();
15762         result = (wxFontDialog *)new wxFontDialog(arg1,(wxFontData const &)*arg2);
15763
15764         wxPyEndAllowThreads(__tstate);
15765         if (PyErr_Occurred()) SWIG_fail;
15766     }
15767     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontDialog, 1);
15768     return resultobj;
15769     fail:
15770     return NULL;
15771 }
15772
15773
15774 static PyObject *_wrap_FontDialog_GetFontData(PyObject *, PyObject *args, PyObject *kwargs) {
15775     PyObject *resultobj;
15776     wxFontDialog *arg1 = (wxFontDialog *) 0 ;
15777     wxFontData *result;
15778     PyObject * obj0 = 0 ;
15779     char *kwnames[] = {
15780         (char *) "self", NULL
15781     };
15782
15783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontDialog_GetFontData",kwnames,&obj0)) goto fail;
15784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontDialog, SWIG_POINTER_EXCEPTION | 0);
15785     if (SWIG_arg_fail(1)) SWIG_fail;
15786     {
15787         PyThreadState* __tstate = wxPyBeginAllowThreads();
15788         {
15789             wxFontData &_result_ref = (arg1)->GetFontData();
15790             result = (wxFontData *) &_result_ref;
15791         }
15792
15793         wxPyEndAllowThreads(__tstate);
15794         if (PyErr_Occurred()) SWIG_fail;
15795     }
15796     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 0);
15797     return resultobj;
15798     fail:
15799     return NULL;
15800 }
15801
15802
15803 static PyObject * FontDialog_swigregister(PyObject *, PyObject *args) {
15804     PyObject *obj;
15805     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15806     SWIG_TypeClientData(SWIGTYPE_p_wxFontDialog, obj);
15807     Py_INCREF(obj);
15808     return Py_BuildValue((char *)"");
15809 }
15810 static PyObject *_wrap_new_MessageDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15811     PyObject *resultobj;
15812     wxWindow *arg1 = (wxWindow *) 0 ;
15813     wxString *arg2 = 0 ;
15814     wxString const &arg3_defvalue = wxPyMessageBoxCaptionStr ;
15815     wxString *arg3 = (wxString *) &arg3_defvalue ;
15816     long arg4 = (long) wxOK|wxCANCEL|wxCENTRE ;
15817     wxPoint const &arg5_defvalue = wxDefaultPosition ;
15818     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
15819     wxMessageDialog *result;
15820     bool temp2 = false ;
15821     bool temp3 = false ;
15822     wxPoint temp5 ;
15823     PyObject * obj0 = 0 ;
15824     PyObject * obj1 = 0 ;
15825     PyObject * obj2 = 0 ;
15826     PyObject * obj3 = 0 ;
15827     PyObject * obj4 = 0 ;
15828     char *kwnames[] = {
15829         (char *) "parent",(char *) "message",(char *) "caption",(char *) "style",(char *) "pos", NULL
15830     };
15831
15832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_MessageDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15834     if (SWIG_arg_fail(1)) SWIG_fail;
15835     {
15836         arg2 = wxString_in_helper(obj1);
15837         if (arg2 == NULL) SWIG_fail;
15838         temp2 = true;
15839     }
15840     if (obj2) {
15841         {
15842             arg3 = wxString_in_helper(obj2);
15843             if (arg3 == NULL) SWIG_fail;
15844             temp3 = true;
15845         }
15846     }
15847     if (obj3) {
15848         {
15849             arg4 = (long)(SWIG_As_long(obj3));
15850             if (SWIG_arg_fail(4)) SWIG_fail;
15851         }
15852     }
15853     if (obj4) {
15854         {
15855             arg5 = &temp5;
15856             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
15857         }
15858     }
15859     {
15860         if (!wxPyCheckForApp()) SWIG_fail;
15861         PyThreadState* __tstate = wxPyBeginAllowThreads();
15862         result = (wxMessageDialog *)new wxMessageDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5);
15863
15864         wxPyEndAllowThreads(__tstate);
15865         if (PyErr_Occurred()) SWIG_fail;
15866     }
15867     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMessageDialog, 1);
15868     {
15869         if (temp2)
15870         delete arg2;
15871     }
15872     {
15873         if (temp3)
15874         delete arg3;
15875     }
15876     return resultobj;
15877     fail:
15878     {
15879         if (temp2)
15880         delete arg2;
15881     }
15882     {
15883         if (temp3)
15884         delete arg3;
15885     }
15886     return NULL;
15887 }
15888
15889
15890 static PyObject * MessageDialog_swigregister(PyObject *, PyObject *args) {
15891     PyObject *obj;
15892     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15893     SWIG_TypeClientData(SWIGTYPE_p_wxMessageDialog, obj);
15894     Py_INCREF(obj);
15895     return Py_BuildValue((char *)"");
15896 }
15897 static PyObject *_wrap_new_ProgressDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15898     PyObject *resultobj;
15899     wxString *arg1 = 0 ;
15900     wxString *arg2 = 0 ;
15901     int arg3 = (int) 100 ;
15902     wxWindow *arg4 = (wxWindow *) NULL ;
15903     int arg5 = (int) wxPD_AUTO_HIDE|wxPD_APP_MODAL ;
15904     wxProgressDialog *result;
15905     bool temp1 = false ;
15906     bool temp2 = false ;
15907     PyObject * obj0 = 0 ;
15908     PyObject * obj1 = 0 ;
15909     PyObject * obj2 = 0 ;
15910     PyObject * obj3 = 0 ;
15911     PyObject * obj4 = 0 ;
15912     char *kwnames[] = {
15913         (char *) "title",(char *) "message",(char *) "maximum",(char *) "parent",(char *) "style", NULL
15914     };
15915
15916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_ProgressDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15917     {
15918         arg1 = wxString_in_helper(obj0);
15919         if (arg1 == NULL) SWIG_fail;
15920         temp1 = true;
15921     }
15922     {
15923         arg2 = wxString_in_helper(obj1);
15924         if (arg2 == NULL) SWIG_fail;
15925         temp2 = true;
15926     }
15927     if (obj2) {
15928         {
15929             arg3 = (int)(SWIG_As_int(obj2));
15930             if (SWIG_arg_fail(3)) SWIG_fail;
15931         }
15932     }
15933     if (obj3) {
15934         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15935         if (SWIG_arg_fail(4)) SWIG_fail;
15936     }
15937     if (obj4) {
15938         {
15939             arg5 = (int)(SWIG_As_int(obj4));
15940             if (SWIG_arg_fail(5)) SWIG_fail;
15941         }
15942     }
15943     {
15944         if (!wxPyCheckForApp()) SWIG_fail;
15945         PyThreadState* __tstate = wxPyBeginAllowThreads();
15946         result = (wxProgressDialog *)new wxProgressDialog((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5);
15947
15948         wxPyEndAllowThreads(__tstate);
15949         if (PyErr_Occurred()) SWIG_fail;
15950     }
15951     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProgressDialog, 1);
15952     {
15953         if (temp1)
15954         delete arg1;
15955     }
15956     {
15957         if (temp2)
15958         delete arg2;
15959     }
15960     return resultobj;
15961     fail:
15962     {
15963         if (temp1)
15964         delete arg1;
15965     }
15966     {
15967         if (temp2)
15968         delete arg2;
15969     }
15970     return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_ProgressDialog_Update(PyObject *, PyObject *args, PyObject *kwargs) {
15975     PyObject *resultobj;
15976     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15977     int arg2 ;
15978     wxString const &arg3_defvalue = wxPyEmptyString ;
15979     wxString *arg3 = (wxString *) &arg3_defvalue ;
15980     bool result;
15981     bool temp3 = false ;
15982     PyObject * obj0 = 0 ;
15983     PyObject * obj1 = 0 ;
15984     PyObject * obj2 = 0 ;
15985     char *kwnames[] = {
15986         (char *) "self",(char *) "value",(char *) "newmsg", NULL
15987     };
15988
15989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ProgressDialog_Update",kwnames,&obj0,&obj1,&obj2)) goto fail;
15990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15991     if (SWIG_arg_fail(1)) SWIG_fail;
15992     {
15993         arg2 = (int)(SWIG_As_int(obj1));
15994         if (SWIG_arg_fail(2)) SWIG_fail;
15995     }
15996     if (obj2) {
15997         {
15998             arg3 = wxString_in_helper(obj2);
15999             if (arg3 == NULL) SWIG_fail;
16000             temp3 = true;
16001         }
16002     }
16003     {
16004         PyThreadState* __tstate = wxPyBeginAllowThreads();
16005         result = (bool)(arg1)->Update(arg2,(wxString const &)*arg3);
16006
16007         wxPyEndAllowThreads(__tstate);
16008         if (PyErr_Occurred()) SWIG_fail;
16009     }
16010     {
16011         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16012     }
16013     {
16014         if (temp3)
16015         delete arg3;
16016     }
16017     return resultobj;
16018     fail:
16019     {
16020         if (temp3)
16021         delete arg3;
16022     }
16023     return NULL;
16024 }
16025
16026
16027 static PyObject *_wrap_ProgressDialog_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
16028     PyObject *resultobj;
16029     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
16030     PyObject * obj0 = 0 ;
16031     char *kwnames[] = {
16032         (char *) "self", NULL
16033     };
16034
16035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProgressDialog_Resume",kwnames,&obj0)) goto fail;
16036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
16037     if (SWIG_arg_fail(1)) SWIG_fail;
16038     {
16039         PyThreadState* __tstate = wxPyBeginAllowThreads();
16040         (arg1)->Resume();
16041
16042         wxPyEndAllowThreads(__tstate);
16043         if (PyErr_Occurred()) SWIG_fail;
16044     }
16045     Py_INCREF(Py_None); resultobj = Py_None;
16046     return resultobj;
16047     fail:
16048     return NULL;
16049 }
16050
16051
16052 static PyObject * ProgressDialog_swigregister(PyObject *, PyObject *args) {
16053     PyObject *obj;
16054     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16055     SWIG_TypeClientData(SWIGTYPE_p_wxProgressDialog, obj);
16056     Py_INCREF(obj);
16057     return Py_BuildValue((char *)"");
16058 }
16059 static PyObject *_wrap_new_FindDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16060     PyObject *resultobj;
16061     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16062     int arg2 = (int) 0 ;
16063     wxFindDialogEvent *result;
16064     PyObject * obj0 = 0 ;
16065     PyObject * obj1 = 0 ;
16066     char *kwnames[] = {
16067         (char *) "commandType",(char *) "id", NULL
16068     };
16069
16070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FindDialogEvent",kwnames,&obj0,&obj1)) goto fail;
16071     if (obj0) {
16072         {
16073             arg1 = (wxEventType)(SWIG_As_int(obj0));
16074             if (SWIG_arg_fail(1)) SWIG_fail;
16075         }
16076     }
16077     if (obj1) {
16078         {
16079             arg2 = (int)(SWIG_As_int(obj1));
16080             if (SWIG_arg_fail(2)) SWIG_fail;
16081         }
16082     }
16083     {
16084         PyThreadState* __tstate = wxPyBeginAllowThreads();
16085         result = (wxFindDialogEvent *)new wxFindDialogEvent(arg1,arg2);
16086
16087         wxPyEndAllowThreads(__tstate);
16088         if (PyErr_Occurred()) SWIG_fail;
16089     }
16090     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindDialogEvent, 1);
16091     return resultobj;
16092     fail:
16093     return NULL;
16094 }
16095
16096
16097 static PyObject *_wrap_FindDialogEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16098     PyObject *resultobj;
16099     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16100     int result;
16101     PyObject * obj0 = 0 ;
16102     char *kwnames[] = {
16103         (char *) "self", NULL
16104     };
16105
16106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFlags",kwnames,&obj0)) goto fail;
16107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16108     if (SWIG_arg_fail(1)) SWIG_fail;
16109     {
16110         PyThreadState* __tstate = wxPyBeginAllowThreads();
16111         result = (int)(arg1)->GetFlags();
16112
16113         wxPyEndAllowThreads(__tstate);
16114         if (PyErr_Occurred()) SWIG_fail;
16115     }
16116     {
16117         resultobj = SWIG_From_int((int)(result));
16118     }
16119     return resultobj;
16120     fail:
16121     return NULL;
16122 }
16123
16124
16125 static PyObject *_wrap_FindDialogEvent_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16126     PyObject *resultobj;
16127     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16128     wxString *result;
16129     PyObject * obj0 = 0 ;
16130     char *kwnames[] = {
16131         (char *) "self", NULL
16132     };
16133
16134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFindString",kwnames,&obj0)) goto fail;
16135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16136     if (SWIG_arg_fail(1)) SWIG_fail;
16137     {
16138         PyThreadState* __tstate = wxPyBeginAllowThreads();
16139         {
16140             wxString const &_result_ref = (arg1)->GetFindString();
16141             result = (wxString *) &_result_ref;
16142         }
16143
16144         wxPyEndAllowThreads(__tstate);
16145         if (PyErr_Occurred()) SWIG_fail;
16146     }
16147     {
16148 #if wxUSE_UNICODE
16149         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16150 #else
16151         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16152 #endif
16153     }
16154     return resultobj;
16155     fail:
16156     return NULL;
16157 }
16158
16159
16160 static PyObject *_wrap_FindDialogEvent_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16161     PyObject *resultobj;
16162     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16163     wxString *result;
16164     PyObject * obj0 = 0 ;
16165     char *kwnames[] = {
16166         (char *) "self", NULL
16167     };
16168
16169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetReplaceString",kwnames,&obj0)) goto fail;
16170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16171     if (SWIG_arg_fail(1)) SWIG_fail;
16172     {
16173         PyThreadState* __tstate = wxPyBeginAllowThreads();
16174         {
16175             wxString const &_result_ref = (arg1)->GetReplaceString();
16176             result = (wxString *) &_result_ref;
16177         }
16178
16179         wxPyEndAllowThreads(__tstate);
16180         if (PyErr_Occurred()) SWIG_fail;
16181     }
16182     {
16183 #if wxUSE_UNICODE
16184         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16185 #else
16186         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16187 #endif
16188     }
16189     return resultobj;
16190     fail:
16191     return NULL;
16192 }
16193
16194
16195 static PyObject *_wrap_FindDialogEvent_GetDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16196     PyObject *resultobj;
16197     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16198     wxFindReplaceDialog *result;
16199     PyObject * obj0 = 0 ;
16200     char *kwnames[] = {
16201         (char *) "self", NULL
16202     };
16203
16204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetDialog",kwnames,&obj0)) goto fail;
16205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16206     if (SWIG_arg_fail(1)) SWIG_fail;
16207     {
16208         PyThreadState* __tstate = wxPyBeginAllowThreads();
16209         result = (wxFindReplaceDialog *)(arg1)->GetDialog();
16210
16211         wxPyEndAllowThreads(__tstate);
16212         if (PyErr_Occurred()) SWIG_fail;
16213     }
16214     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 0);
16215     return resultobj;
16216     fail:
16217     return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_FindDialogEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16222     PyObject *resultobj;
16223     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16224     int arg2 ;
16225     PyObject * obj0 = 0 ;
16226     PyObject * obj1 = 0 ;
16227     char *kwnames[] = {
16228         (char *) "self",(char *) "flags", NULL
16229     };
16230
16231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16232     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16233     if (SWIG_arg_fail(1)) SWIG_fail;
16234     {
16235         arg2 = (int)(SWIG_As_int(obj1));
16236         if (SWIG_arg_fail(2)) SWIG_fail;
16237     }
16238     {
16239         PyThreadState* __tstate = wxPyBeginAllowThreads();
16240         (arg1)->SetFlags(arg2);
16241
16242         wxPyEndAllowThreads(__tstate);
16243         if (PyErr_Occurred()) SWIG_fail;
16244     }
16245     Py_INCREF(Py_None); resultobj = Py_None;
16246     return resultobj;
16247     fail:
16248     return NULL;
16249 }
16250
16251
16252 static PyObject *_wrap_FindDialogEvent_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16253     PyObject *resultobj;
16254     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16255     wxString *arg2 = 0 ;
16256     bool temp2 = false ;
16257     PyObject * obj0 = 0 ;
16258     PyObject * obj1 = 0 ;
16259     char *kwnames[] = {
16260         (char *) "self",(char *) "str", NULL
16261     };
16262
16263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16265     if (SWIG_arg_fail(1)) SWIG_fail;
16266     {
16267         arg2 = wxString_in_helper(obj1);
16268         if (arg2 == NULL) SWIG_fail;
16269         temp2 = true;
16270     }
16271     {
16272         PyThreadState* __tstate = wxPyBeginAllowThreads();
16273         (arg1)->SetFindString((wxString const &)*arg2);
16274
16275         wxPyEndAllowThreads(__tstate);
16276         if (PyErr_Occurred()) SWIG_fail;
16277     }
16278     Py_INCREF(Py_None); resultobj = Py_None;
16279     {
16280         if (temp2)
16281         delete arg2;
16282     }
16283     return resultobj;
16284     fail:
16285     {
16286         if (temp2)
16287         delete arg2;
16288     }
16289     return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_FindDialogEvent_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16294     PyObject *resultobj;
16295     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16296     wxString *arg2 = 0 ;
16297     bool temp2 = false ;
16298     PyObject * obj0 = 0 ;
16299     PyObject * obj1 = 0 ;
16300     char *kwnames[] = {
16301         (char *) "self",(char *) "str", NULL
16302     };
16303
16304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16306     if (SWIG_arg_fail(1)) SWIG_fail;
16307     {
16308         arg2 = wxString_in_helper(obj1);
16309         if (arg2 == NULL) SWIG_fail;
16310         temp2 = true;
16311     }
16312     {
16313         PyThreadState* __tstate = wxPyBeginAllowThreads();
16314         (arg1)->SetReplaceString((wxString const &)*arg2);
16315
16316         wxPyEndAllowThreads(__tstate);
16317         if (PyErr_Occurred()) SWIG_fail;
16318     }
16319     Py_INCREF(Py_None); resultobj = Py_None;
16320     {
16321         if (temp2)
16322         delete arg2;
16323     }
16324     return resultobj;
16325     fail:
16326     {
16327         if (temp2)
16328         delete arg2;
16329     }
16330     return NULL;
16331 }
16332
16333
16334 static PyObject * FindDialogEvent_swigregister(PyObject *, PyObject *args) {
16335     PyObject *obj;
16336     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16337     SWIG_TypeClientData(SWIGTYPE_p_wxFindDialogEvent, obj);
16338     Py_INCREF(obj);
16339     return Py_BuildValue((char *)"");
16340 }
16341 static PyObject *_wrap_new_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16342     PyObject *resultobj;
16343     int arg1 = (int) 0 ;
16344     wxFindReplaceData *result;
16345     PyObject * obj0 = 0 ;
16346     char *kwnames[] = {
16347         (char *) "flags", NULL
16348     };
16349
16350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_FindReplaceData",kwnames,&obj0)) goto fail;
16351     if (obj0) {
16352         {
16353             arg1 = (int)(SWIG_As_int(obj0));
16354             if (SWIG_arg_fail(1)) SWIG_fail;
16355         }
16356     }
16357     {
16358         PyThreadState* __tstate = wxPyBeginAllowThreads();
16359         result = (wxFindReplaceData *)new wxFindReplaceData(arg1);
16360
16361         wxPyEndAllowThreads(__tstate);
16362         if (PyErr_Occurred()) SWIG_fail;
16363     }
16364     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 1);
16365     return resultobj;
16366     fail:
16367     return NULL;
16368 }
16369
16370
16371 static PyObject *_wrap_delete_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16372     PyObject *resultobj;
16373     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16374     PyObject * obj0 = 0 ;
16375     char *kwnames[] = {
16376         (char *) "self", NULL
16377     };
16378
16379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FindReplaceData",kwnames,&obj0)) goto fail;
16380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16381     if (SWIG_arg_fail(1)) SWIG_fail;
16382     {
16383         PyThreadState* __tstate = wxPyBeginAllowThreads();
16384         delete arg1;
16385
16386         wxPyEndAllowThreads(__tstate);
16387         if (PyErr_Occurred()) SWIG_fail;
16388     }
16389     Py_INCREF(Py_None); resultobj = Py_None;
16390     return resultobj;
16391     fail:
16392     return NULL;
16393 }
16394
16395
16396 static PyObject *_wrap_FindReplaceData_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16397     PyObject *resultobj;
16398     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16399     wxString *result;
16400     PyObject * obj0 = 0 ;
16401     char *kwnames[] = {
16402         (char *) "self", NULL
16403     };
16404
16405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFindString",kwnames,&obj0)) goto fail;
16406     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16407     if (SWIG_arg_fail(1)) SWIG_fail;
16408     {
16409         PyThreadState* __tstate = wxPyBeginAllowThreads();
16410         {
16411             wxString const &_result_ref = (arg1)->GetFindString();
16412             result = (wxString *) &_result_ref;
16413         }
16414
16415         wxPyEndAllowThreads(__tstate);
16416         if (PyErr_Occurred()) SWIG_fail;
16417     }
16418     {
16419 #if wxUSE_UNICODE
16420         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16421 #else
16422         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16423 #endif
16424     }
16425     return resultobj;
16426     fail:
16427     return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_FindReplaceData_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16432     PyObject *resultobj;
16433     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16434     wxString *result;
16435     PyObject * obj0 = 0 ;
16436     char *kwnames[] = {
16437         (char *) "self", NULL
16438     };
16439
16440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetReplaceString",kwnames,&obj0)) goto fail;
16441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16442     if (SWIG_arg_fail(1)) SWIG_fail;
16443     {
16444         PyThreadState* __tstate = wxPyBeginAllowThreads();
16445         {
16446             wxString const &_result_ref = (arg1)->GetReplaceString();
16447             result = (wxString *) &_result_ref;
16448         }
16449
16450         wxPyEndAllowThreads(__tstate);
16451         if (PyErr_Occurred()) SWIG_fail;
16452     }
16453     {
16454 #if wxUSE_UNICODE
16455         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16456 #else
16457         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16458 #endif
16459     }
16460     return resultobj;
16461     fail:
16462     return NULL;
16463 }
16464
16465
16466 static PyObject *_wrap_FindReplaceData_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16467     PyObject *resultobj;
16468     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16469     int result;
16470     PyObject * obj0 = 0 ;
16471     char *kwnames[] = {
16472         (char *) "self", NULL
16473     };
16474
16475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFlags",kwnames,&obj0)) goto fail;
16476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16477     if (SWIG_arg_fail(1)) SWIG_fail;
16478     {
16479         PyThreadState* __tstate = wxPyBeginAllowThreads();
16480         result = (int)(arg1)->GetFlags();
16481
16482         wxPyEndAllowThreads(__tstate);
16483         if (PyErr_Occurred()) SWIG_fail;
16484     }
16485     {
16486         resultobj = SWIG_From_int((int)(result));
16487     }
16488     return resultobj;
16489     fail:
16490     return NULL;
16491 }
16492
16493
16494 static PyObject *_wrap_FindReplaceData_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16495     PyObject *resultobj;
16496     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16497     int arg2 ;
16498     PyObject * obj0 = 0 ;
16499     PyObject * obj1 = 0 ;
16500     char *kwnames[] = {
16501         (char *) "self",(char *) "flags", NULL
16502     };
16503
16504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16506     if (SWIG_arg_fail(1)) SWIG_fail;
16507     {
16508         arg2 = (int)(SWIG_As_int(obj1));
16509         if (SWIG_arg_fail(2)) SWIG_fail;
16510     }
16511     {
16512         PyThreadState* __tstate = wxPyBeginAllowThreads();
16513         (arg1)->SetFlags(arg2);
16514
16515         wxPyEndAllowThreads(__tstate);
16516         if (PyErr_Occurred()) SWIG_fail;
16517     }
16518     Py_INCREF(Py_None); resultobj = Py_None;
16519     return resultobj;
16520     fail:
16521     return NULL;
16522 }
16523
16524
16525 static PyObject *_wrap_FindReplaceData_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16526     PyObject *resultobj;
16527     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16528     wxString *arg2 = 0 ;
16529     bool temp2 = false ;
16530     PyObject * obj0 = 0 ;
16531     PyObject * obj1 = 0 ;
16532     char *kwnames[] = {
16533         (char *) "self",(char *) "str", NULL
16534     };
16535
16536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16538     if (SWIG_arg_fail(1)) SWIG_fail;
16539     {
16540         arg2 = wxString_in_helper(obj1);
16541         if (arg2 == NULL) SWIG_fail;
16542         temp2 = true;
16543     }
16544     {
16545         PyThreadState* __tstate = wxPyBeginAllowThreads();
16546         (arg1)->SetFindString((wxString const &)*arg2);
16547
16548         wxPyEndAllowThreads(__tstate);
16549         if (PyErr_Occurred()) SWIG_fail;
16550     }
16551     Py_INCREF(Py_None); resultobj = Py_None;
16552     {
16553         if (temp2)
16554         delete arg2;
16555     }
16556     return resultobj;
16557     fail:
16558     {
16559         if (temp2)
16560         delete arg2;
16561     }
16562     return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_FindReplaceData_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16567     PyObject *resultobj;
16568     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16569     wxString *arg2 = 0 ;
16570     bool temp2 = false ;
16571     PyObject * obj0 = 0 ;
16572     PyObject * obj1 = 0 ;
16573     char *kwnames[] = {
16574         (char *) "self",(char *) "str", NULL
16575     };
16576
16577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16579     if (SWIG_arg_fail(1)) SWIG_fail;
16580     {
16581         arg2 = wxString_in_helper(obj1);
16582         if (arg2 == NULL) SWIG_fail;
16583         temp2 = true;
16584     }
16585     {
16586         PyThreadState* __tstate = wxPyBeginAllowThreads();
16587         (arg1)->SetReplaceString((wxString const &)*arg2);
16588
16589         wxPyEndAllowThreads(__tstate);
16590         if (PyErr_Occurred()) SWIG_fail;
16591     }
16592     Py_INCREF(Py_None); resultobj = Py_None;
16593     {
16594         if (temp2)
16595         delete arg2;
16596     }
16597     return resultobj;
16598     fail:
16599     {
16600         if (temp2)
16601         delete arg2;
16602     }
16603     return NULL;
16604 }
16605
16606
16607 static PyObject * FindReplaceData_swigregister(PyObject *, PyObject *args) {
16608     PyObject *obj;
16609     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16610     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceData, obj);
16611     Py_INCREF(obj);
16612     return Py_BuildValue((char *)"");
16613 }
16614 static PyObject *_wrap_new_FindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16615     PyObject *resultobj;
16616     wxWindow *arg1 = (wxWindow *) 0 ;
16617     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16618     wxString *arg3 = 0 ;
16619     int arg4 = (int) 0 ;
16620     wxFindReplaceDialog *result;
16621     bool temp3 = false ;
16622     PyObject * obj0 = 0 ;
16623     PyObject * obj1 = 0 ;
16624     PyObject * obj2 = 0 ;
16625     PyObject * obj3 = 0 ;
16626     char *kwnames[] = {
16627         (char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16628     };
16629
16630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_FindReplaceDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16631     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16632     if (SWIG_arg_fail(1)) SWIG_fail;
16633     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16634     if (SWIG_arg_fail(2)) SWIG_fail;
16635     {
16636         arg3 = wxString_in_helper(obj2);
16637         if (arg3 == NULL) SWIG_fail;
16638         temp3 = true;
16639     }
16640     if (obj3) {
16641         {
16642             arg4 = (int)(SWIG_As_int(obj3));
16643             if (SWIG_arg_fail(4)) SWIG_fail;
16644         }
16645     }
16646     {
16647         if (!wxPyCheckForApp()) SWIG_fail;
16648         PyThreadState* __tstate = wxPyBeginAllowThreads();
16649         result = (wxFindReplaceDialog *)new wxFindReplaceDialog(arg1,arg2,(wxString const &)*arg3,arg4);
16650
16651         wxPyEndAllowThreads(__tstate);
16652         if (PyErr_Occurred()) SWIG_fail;
16653     }
16654     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16655     {
16656         if (temp3)
16657         delete arg3;
16658     }
16659     return resultobj;
16660     fail:
16661     {
16662         if (temp3)
16663         delete arg3;
16664     }
16665     return NULL;
16666 }
16667
16668
16669 static PyObject *_wrap_new_PreFindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16670     PyObject *resultobj;
16671     wxFindReplaceDialog *result;
16672     char *kwnames[] = {
16673         NULL
16674     };
16675
16676     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFindReplaceDialog",kwnames)) goto fail;
16677     {
16678         if (!wxPyCheckForApp()) SWIG_fail;
16679         PyThreadState* __tstate = wxPyBeginAllowThreads();
16680         result = (wxFindReplaceDialog *)new wxFindReplaceDialog();
16681
16682         wxPyEndAllowThreads(__tstate);
16683         if (PyErr_Occurred()) SWIG_fail;
16684     }
16685     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16686     return resultobj;
16687     fail:
16688     return NULL;
16689 }
16690
16691
16692 static PyObject *_wrap_FindReplaceDialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16693     PyObject *resultobj;
16694     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16695     wxWindow *arg2 = (wxWindow *) 0 ;
16696     wxFindReplaceData *arg3 = (wxFindReplaceData *) 0 ;
16697     wxString *arg4 = 0 ;
16698     int arg5 = (int) 0 ;
16699     bool result;
16700     bool temp4 = false ;
16701     PyObject * obj0 = 0 ;
16702     PyObject * obj1 = 0 ;
16703     PyObject * obj2 = 0 ;
16704     PyObject * obj3 = 0 ;
16705     PyObject * obj4 = 0 ;
16706     char *kwnames[] = {
16707         (char *) "self",(char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16708     };
16709
16710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:FindReplaceDialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16711     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16712     if (SWIG_arg_fail(1)) SWIG_fail;
16713     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16714     if (SWIG_arg_fail(2)) SWIG_fail;
16715     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16716     if (SWIG_arg_fail(3)) SWIG_fail;
16717     {
16718         arg4 = wxString_in_helper(obj3);
16719         if (arg4 == NULL) SWIG_fail;
16720         temp4 = true;
16721     }
16722     if (obj4) {
16723         {
16724             arg5 = (int)(SWIG_As_int(obj4));
16725             if (SWIG_arg_fail(5)) SWIG_fail;
16726         }
16727     }
16728     {
16729         PyThreadState* __tstate = wxPyBeginAllowThreads();
16730         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,arg5);
16731
16732         wxPyEndAllowThreads(__tstate);
16733         if (PyErr_Occurred()) SWIG_fail;
16734     }
16735     {
16736         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16737     }
16738     {
16739         if (temp4)
16740         delete arg4;
16741     }
16742     return resultobj;
16743     fail:
16744     {
16745         if (temp4)
16746         delete arg4;
16747     }
16748     return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_FindReplaceDialog_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
16753     PyObject *resultobj;
16754     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16755     wxFindReplaceData *result;
16756     PyObject * obj0 = 0 ;
16757     char *kwnames[] = {
16758         (char *) "self", NULL
16759     };
16760
16761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceDialog_GetData",kwnames,&obj0)) goto fail;
16762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16763     if (SWIG_arg_fail(1)) SWIG_fail;
16764     {
16765         PyThreadState* __tstate = wxPyBeginAllowThreads();
16766         result = (wxFindReplaceData *)(arg1)->GetData();
16767
16768         wxPyEndAllowThreads(__tstate);
16769         if (PyErr_Occurred()) SWIG_fail;
16770     }
16771     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 0);
16772     return resultobj;
16773     fail:
16774     return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_FindReplaceDialog_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
16779     PyObject *resultobj;
16780     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16781     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16782     PyObject * obj0 = 0 ;
16783     PyObject * obj1 = 0 ;
16784     char *kwnames[] = {
16785         (char *) "self",(char *) "data", NULL
16786     };
16787
16788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceDialog_SetData",kwnames,&obj0,&obj1)) goto fail;
16789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16790     if (SWIG_arg_fail(1)) SWIG_fail;
16791     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16792     if (SWIG_arg_fail(2)) SWIG_fail;
16793     {
16794         PyThreadState* __tstate = wxPyBeginAllowThreads();
16795         (arg1)->SetData(arg2);
16796
16797         wxPyEndAllowThreads(__tstate);
16798         if (PyErr_Occurred()) SWIG_fail;
16799     }
16800     Py_INCREF(Py_None); resultobj = Py_None;
16801     return resultobj;
16802     fail:
16803     return NULL;
16804 }
16805
16806
16807 static PyObject * FindReplaceDialog_swigregister(PyObject *, PyObject *args) {
16808     PyObject *obj;
16809     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16810     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceDialog, obj);
16811     Py_INCREF(obj);
16812     return Py_BuildValue((char *)"");
16813 }
16814 static PyObject *_wrap_new_MDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16815     PyObject *resultobj;
16816     wxWindow *arg1 = (wxWindow *) 0 ;
16817     int arg2 = (int) (int)-1 ;
16818     wxString const &arg3_defvalue = wxPyEmptyString ;
16819     wxString *arg3 = (wxString *) &arg3_defvalue ;
16820     wxPoint const &arg4_defvalue = wxDefaultPosition ;
16821     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
16822     wxSize const &arg5_defvalue = wxDefaultSize ;
16823     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
16824     long arg6 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16825     wxString const &arg7_defvalue = wxPyFrameNameStr ;
16826     wxString *arg7 = (wxString *) &arg7_defvalue ;
16827     wxMDIParentFrame *result;
16828     bool temp3 = false ;
16829     wxPoint temp4 ;
16830     wxSize temp5 ;
16831     bool temp7 = false ;
16832     PyObject * obj0 = 0 ;
16833     PyObject * obj1 = 0 ;
16834     PyObject * obj2 = 0 ;
16835     PyObject * obj3 = 0 ;
16836     PyObject * obj4 = 0 ;
16837     PyObject * obj5 = 0 ;
16838     PyObject * obj6 = 0 ;
16839     char *kwnames[] = {
16840         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16841     };
16842
16843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIParentFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
16844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16845     if (SWIG_arg_fail(1)) SWIG_fail;
16846     if (obj1) {
16847         {
16848             arg2 = (int const)(SWIG_As_int(obj1));
16849             if (SWIG_arg_fail(2)) SWIG_fail;
16850         }
16851     }
16852     if (obj2) {
16853         {
16854             arg3 = wxString_in_helper(obj2);
16855             if (arg3 == NULL) SWIG_fail;
16856             temp3 = true;
16857         }
16858     }
16859     if (obj3) {
16860         {
16861             arg4 = &temp4;
16862             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
16863         }
16864     }
16865     if (obj4) {
16866         {
16867             arg5 = &temp5;
16868             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
16869         }
16870     }
16871     if (obj5) {
16872         {
16873             arg6 = (long)(SWIG_As_long(obj5));
16874             if (SWIG_arg_fail(6)) SWIG_fail;
16875         }
16876     }
16877     if (obj6) {
16878         {
16879             arg7 = wxString_in_helper(obj6);
16880             if (arg7 == NULL) SWIG_fail;
16881             temp7 = true;
16882         }
16883     }
16884     {
16885         if (!wxPyCheckForApp()) SWIG_fail;
16886         PyThreadState* __tstate = wxPyBeginAllowThreads();
16887         result = (wxMDIParentFrame *)new wxMDIParentFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
16888
16889         wxPyEndAllowThreads(__tstate);
16890         if (PyErr_Occurred()) SWIG_fail;
16891     }
16892     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16893     {
16894         if (temp3)
16895         delete arg3;
16896     }
16897     {
16898         if (temp7)
16899         delete arg7;
16900     }
16901     return resultobj;
16902     fail:
16903     {
16904         if (temp3)
16905         delete arg3;
16906     }
16907     {
16908         if (temp7)
16909         delete arg7;
16910     }
16911     return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_new_PreMDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16916     PyObject *resultobj;
16917     wxMDIParentFrame *result;
16918     char *kwnames[] = {
16919         NULL
16920     };
16921
16922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIParentFrame",kwnames)) goto fail;
16923     {
16924         if (!wxPyCheckForApp()) SWIG_fail;
16925         PyThreadState* __tstate = wxPyBeginAllowThreads();
16926         result = (wxMDIParentFrame *)new wxMDIParentFrame();
16927
16928         wxPyEndAllowThreads(__tstate);
16929         if (PyErr_Occurred()) SWIG_fail;
16930     }
16931     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16932     return resultobj;
16933     fail:
16934     return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_MDIParentFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16939     PyObject *resultobj;
16940     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16941     wxWindow *arg2 = (wxWindow *) 0 ;
16942     int arg3 = (int) (int)-1 ;
16943     wxString const &arg4_defvalue = wxPyEmptyString ;
16944     wxString *arg4 = (wxString *) &arg4_defvalue ;
16945     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16946     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16947     wxSize const &arg6_defvalue = wxDefaultSize ;
16948     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16949     long arg7 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16950     wxString const &arg8_defvalue = wxPyFrameNameStr ;
16951     wxString *arg8 = (wxString *) &arg8_defvalue ;
16952     bool result;
16953     bool temp4 = false ;
16954     wxPoint temp5 ;
16955     wxSize temp6 ;
16956     bool temp8 = false ;
16957     PyObject * obj0 = 0 ;
16958     PyObject * obj1 = 0 ;
16959     PyObject * obj2 = 0 ;
16960     PyObject * obj3 = 0 ;
16961     PyObject * obj4 = 0 ;
16962     PyObject * obj5 = 0 ;
16963     PyObject * obj6 = 0 ;
16964     PyObject * obj7 = 0 ;
16965     char *kwnames[] = {
16966         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16967     };
16968
16969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIParentFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
16970     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16971     if (SWIG_arg_fail(1)) SWIG_fail;
16972     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16973     if (SWIG_arg_fail(2)) SWIG_fail;
16974     if (obj2) {
16975         {
16976             arg3 = (int const)(SWIG_As_int(obj2));
16977             if (SWIG_arg_fail(3)) SWIG_fail;
16978         }
16979     }
16980     if (obj3) {
16981         {
16982             arg4 = wxString_in_helper(obj3);
16983             if (arg4 == NULL) SWIG_fail;
16984             temp4 = true;
16985         }
16986     }
16987     if (obj4) {
16988         {
16989             arg5 = &temp5;
16990             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16991         }
16992     }
16993     if (obj5) {
16994         {
16995             arg6 = &temp6;
16996             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16997         }
16998     }
16999     if (obj6) {
17000         {
17001             arg7 = (long)(SWIG_As_long(obj6));
17002             if (SWIG_arg_fail(7)) SWIG_fail;
17003         }
17004     }
17005     if (obj7) {
17006         {
17007             arg8 = wxString_in_helper(obj7);
17008             if (arg8 == NULL) SWIG_fail;
17009             temp8 = true;
17010         }
17011     }
17012     {
17013         PyThreadState* __tstate = wxPyBeginAllowThreads();
17014         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17015
17016         wxPyEndAllowThreads(__tstate);
17017         if (PyErr_Occurred()) SWIG_fail;
17018     }
17019     {
17020         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17021     }
17022     {
17023         if (temp4)
17024         delete arg4;
17025     }
17026     {
17027         if (temp8)
17028         delete arg8;
17029     }
17030     return resultobj;
17031     fail:
17032     {
17033         if (temp4)
17034         delete arg4;
17035     }
17036     {
17037         if (temp8)
17038         delete arg8;
17039     }
17040     return NULL;
17041 }
17042
17043
17044 static PyObject *_wrap_MDIParentFrame_ActivateNext(PyObject *, PyObject *args, PyObject *kwargs) {
17045     PyObject *resultobj;
17046     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17047     PyObject * obj0 = 0 ;
17048     char *kwnames[] = {
17049         (char *) "self", NULL
17050     };
17051
17052     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivateNext",kwnames,&obj0)) goto fail;
17053     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17054     if (SWIG_arg_fail(1)) SWIG_fail;
17055     {
17056         PyThreadState* __tstate = wxPyBeginAllowThreads();
17057         (arg1)->ActivateNext();
17058
17059         wxPyEndAllowThreads(__tstate);
17060         if (PyErr_Occurred()) SWIG_fail;
17061     }
17062     Py_INCREF(Py_None); resultobj = Py_None;
17063     return resultobj;
17064     fail:
17065     return NULL;
17066 }
17067
17068
17069 static PyObject *_wrap_MDIParentFrame_ActivatePrevious(PyObject *, PyObject *args, PyObject *kwargs) {
17070     PyObject *resultobj;
17071     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17072     PyObject * obj0 = 0 ;
17073     char *kwnames[] = {
17074         (char *) "self", NULL
17075     };
17076
17077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivatePrevious",kwnames,&obj0)) goto fail;
17078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17079     if (SWIG_arg_fail(1)) SWIG_fail;
17080     {
17081         PyThreadState* __tstate = wxPyBeginAllowThreads();
17082         (arg1)->ActivatePrevious();
17083
17084         wxPyEndAllowThreads(__tstate);
17085         if (PyErr_Occurred()) SWIG_fail;
17086     }
17087     Py_INCREF(Py_None); resultobj = Py_None;
17088     return resultobj;
17089     fail:
17090     return NULL;
17091 }
17092
17093
17094 static PyObject *_wrap_MDIParentFrame_ArrangeIcons(PyObject *, PyObject *args, PyObject *kwargs) {
17095     PyObject *resultobj;
17096     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17097     PyObject * obj0 = 0 ;
17098     char *kwnames[] = {
17099         (char *) "self", NULL
17100     };
17101
17102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ArrangeIcons",kwnames,&obj0)) goto fail;
17103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17104     if (SWIG_arg_fail(1)) SWIG_fail;
17105     {
17106         PyThreadState* __tstate = wxPyBeginAllowThreads();
17107         (arg1)->ArrangeIcons();
17108
17109         wxPyEndAllowThreads(__tstate);
17110         if (PyErr_Occurred()) SWIG_fail;
17111     }
17112     Py_INCREF(Py_None); resultobj = Py_None;
17113     return resultobj;
17114     fail:
17115     return NULL;
17116 }
17117
17118
17119 static PyObject *_wrap_MDIParentFrame_Cascade(PyObject *, PyObject *args, PyObject *kwargs) {
17120     PyObject *resultobj;
17121     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17122     PyObject * obj0 = 0 ;
17123     char *kwnames[] = {
17124         (char *) "self", NULL
17125     };
17126
17127     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Cascade",kwnames,&obj0)) goto fail;
17128     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17129     if (SWIG_arg_fail(1)) SWIG_fail;
17130     {
17131         PyThreadState* __tstate = wxPyBeginAllowThreads();
17132         (arg1)->Cascade();
17133
17134         wxPyEndAllowThreads(__tstate);
17135         if (PyErr_Occurred()) SWIG_fail;
17136     }
17137     Py_INCREF(Py_None); resultobj = Py_None;
17138     return resultobj;
17139     fail:
17140     return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_MDIParentFrame_GetActiveChild(PyObject *, PyObject *args, PyObject *kwargs) {
17145     PyObject *resultobj;
17146     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17147     wxMDIChildFrame *result;
17148     PyObject * obj0 = 0 ;
17149     char *kwnames[] = {
17150         (char *) "self", NULL
17151     };
17152
17153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetActiveChild",kwnames,&obj0)) goto fail;
17154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17155     if (SWIG_arg_fail(1)) SWIG_fail;
17156     {
17157         PyThreadState* __tstate = wxPyBeginAllowThreads();
17158         result = (wxMDIChildFrame *)(arg1)->GetActiveChild();
17159
17160         wxPyEndAllowThreads(__tstate);
17161         if (PyErr_Occurred()) SWIG_fail;
17162     }
17163     {
17164         resultobj = wxPyMake_wxObject(result, 0);
17165     }
17166     return resultobj;
17167     fail:
17168     return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MDIParentFrame_GetClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17173     PyObject *resultobj;
17174     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17175     wxMDIClientWindow *result;
17176     PyObject * obj0 = 0 ;
17177     char *kwnames[] = {
17178         (char *) "self", NULL
17179     };
17180
17181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetClientWindow",kwnames,&obj0)) goto fail;
17182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17183     if (SWIG_arg_fail(1)) SWIG_fail;
17184     {
17185         PyThreadState* __tstate = wxPyBeginAllowThreads();
17186         result = (wxMDIClientWindow *)(arg1)->GetClientWindow();
17187
17188         wxPyEndAllowThreads(__tstate);
17189         if (PyErr_Occurred()) SWIG_fail;
17190     }
17191     {
17192         resultobj = wxPyMake_wxObject(result, 0);
17193     }
17194     return resultobj;
17195     fail:
17196     return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_MDIParentFrame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17201     PyObject *resultobj;
17202     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17203     wxWindow *result;
17204     PyObject * obj0 = 0 ;
17205     char *kwnames[] = {
17206         (char *) "self", NULL
17207     };
17208
17209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetToolBar",kwnames,&obj0)) goto fail;
17210     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17211     if (SWIG_arg_fail(1)) SWIG_fail;
17212     {
17213         PyThreadState* __tstate = wxPyBeginAllowThreads();
17214         result = (wxWindow *)(arg1)->GetToolBar();
17215
17216         wxPyEndAllowThreads(__tstate);
17217         if (PyErr_Occurred()) SWIG_fail;
17218     }
17219     {
17220         resultobj = wxPyMake_wxObject(result, 0);
17221     }
17222     return resultobj;
17223     fail:
17224     return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MDIParentFrame_GetWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
17229     PyObject *resultobj;
17230     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17231     wxMenu *result;
17232     PyObject * obj0 = 0 ;
17233     char *kwnames[] = {
17234         (char *) "self", NULL
17235     };
17236
17237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetWindowMenu",kwnames,&obj0)) goto fail;
17238     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17239     if (SWIG_arg_fail(1)) SWIG_fail;
17240     {
17241         PyThreadState* __tstate = wxPyBeginAllowThreads();
17242         result = (wxMenu *)(arg1)->GetWindowMenu();
17243
17244         wxPyEndAllowThreads(__tstate);
17245         if (PyErr_Occurred()) SWIG_fail;
17246     }
17247     {
17248         resultobj = wxPyMake_wxObject(result, 0);
17249     }
17250     return resultobj;
17251     fail:
17252     return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_MDIParentFrame_SetWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
17257     PyObject *resultobj;
17258     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17259     wxMenu *arg2 = (wxMenu *) 0 ;
17260     PyObject * obj0 = 0 ;
17261     PyObject * obj1 = 0 ;
17262     char *kwnames[] = {
17263         (char *) "self",(char *) "menu", NULL
17264     };
17265
17266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MDIParentFrame_SetWindowMenu",kwnames,&obj0,&obj1)) goto fail;
17267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17268     if (SWIG_arg_fail(1)) SWIG_fail;
17269     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
17270     if (SWIG_arg_fail(2)) SWIG_fail;
17271     {
17272         PyThreadState* __tstate = wxPyBeginAllowThreads();
17273         (arg1)->SetWindowMenu(arg2);
17274
17275         wxPyEndAllowThreads(__tstate);
17276         if (PyErr_Occurred()) SWIG_fail;
17277     }
17278     Py_INCREF(Py_None); resultobj = Py_None;
17279     return resultobj;
17280     fail:
17281     return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_MDIParentFrame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17286     PyObject *resultobj;
17287     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17288     wxToolBar *arg2 = (wxToolBar *) 0 ;
17289     PyObject * obj0 = 0 ;
17290     PyObject * obj1 = 0 ;
17291     char *kwnames[] = {
17292         (char *) "self",(char *) "toolbar", NULL
17293     };
17294
17295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MDIParentFrame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
17296     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17297     if (SWIG_arg_fail(1)) SWIG_fail;
17298     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
17299     if (SWIG_arg_fail(2)) SWIG_fail;
17300     {
17301         PyThreadState* __tstate = wxPyBeginAllowThreads();
17302         (arg1)->SetToolBar(arg2);
17303
17304         wxPyEndAllowThreads(__tstate);
17305         if (PyErr_Occurred()) SWIG_fail;
17306     }
17307     Py_INCREF(Py_None); resultobj = Py_None;
17308     return resultobj;
17309     fail:
17310     return NULL;
17311 }
17312
17313
17314 static PyObject *_wrap_MDIParentFrame_Tile(PyObject *, PyObject *args, PyObject *kwargs) {
17315     PyObject *resultobj;
17316     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17317     wxOrientation arg2 = (wxOrientation) wxHORIZONTAL ;
17318     PyObject * obj0 = 0 ;
17319     PyObject * obj1 = 0 ;
17320     char *kwnames[] = {
17321         (char *) "self",(char *) "orient", NULL
17322     };
17323
17324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIParentFrame_Tile",kwnames,&obj0,&obj1)) goto fail;
17325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17326     if (SWIG_arg_fail(1)) SWIG_fail;
17327     if (obj1) {
17328         {
17329             arg2 = (wxOrientation)(SWIG_As_int(obj1));
17330             if (SWIG_arg_fail(2)) SWIG_fail;
17331         }
17332     }
17333     {
17334         PyThreadState* __tstate = wxPyBeginAllowThreads();
17335         (arg1)->Tile((wxOrientation )arg2);
17336
17337         wxPyEndAllowThreads(__tstate);
17338         if (PyErr_Occurred()) SWIG_fail;
17339     }
17340     Py_INCREF(Py_None); resultobj = Py_None;
17341     return resultobj;
17342     fail:
17343     return NULL;
17344 }
17345
17346
17347 static PyObject * MDIParentFrame_swigregister(PyObject *, PyObject *args) {
17348     PyObject *obj;
17349     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17350     SWIG_TypeClientData(SWIGTYPE_p_wxMDIParentFrame, obj);
17351     Py_INCREF(obj);
17352     return Py_BuildValue((char *)"");
17353 }
17354 static PyObject *_wrap_new_MDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17355     PyObject *resultobj;
17356     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17357     int arg2 = (int) (int)-1 ;
17358     wxString const &arg3_defvalue = wxPyEmptyString ;
17359     wxString *arg3 = (wxString *) &arg3_defvalue ;
17360     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17361     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17362     wxSize const &arg5_defvalue = wxDefaultSize ;
17363     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17364     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
17365     wxString const &arg7_defvalue = wxPyFrameNameStr ;
17366     wxString *arg7 = (wxString *) &arg7_defvalue ;
17367     wxMDIChildFrame *result;
17368     bool temp3 = false ;
17369     wxPoint temp4 ;
17370     wxSize temp5 ;
17371     bool temp7 = false ;
17372     PyObject * obj0 = 0 ;
17373     PyObject * obj1 = 0 ;
17374     PyObject * obj2 = 0 ;
17375     PyObject * obj3 = 0 ;
17376     PyObject * obj4 = 0 ;
17377     PyObject * obj5 = 0 ;
17378     PyObject * obj6 = 0 ;
17379     char *kwnames[] = {
17380         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17381     };
17382
17383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIChildFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17384     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17385     if (SWIG_arg_fail(1)) SWIG_fail;
17386     if (obj1) {
17387         {
17388             arg2 = (int const)(SWIG_As_int(obj1));
17389             if (SWIG_arg_fail(2)) SWIG_fail;
17390         }
17391     }
17392     if (obj2) {
17393         {
17394             arg3 = wxString_in_helper(obj2);
17395             if (arg3 == NULL) SWIG_fail;
17396             temp3 = true;
17397         }
17398     }
17399     if (obj3) {
17400         {
17401             arg4 = &temp4;
17402             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17403         }
17404     }
17405     if (obj4) {
17406         {
17407             arg5 = &temp5;
17408             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17409         }
17410     }
17411     if (obj5) {
17412         {
17413             arg6 = (long)(SWIG_As_long(obj5));
17414             if (SWIG_arg_fail(6)) SWIG_fail;
17415         }
17416     }
17417     if (obj6) {
17418         {
17419             arg7 = wxString_in_helper(obj6);
17420             if (arg7 == NULL) SWIG_fail;
17421             temp7 = true;
17422         }
17423     }
17424     {
17425         if (!wxPyCheckForApp()) SWIG_fail;
17426         PyThreadState* __tstate = wxPyBeginAllowThreads();
17427         result = (wxMDIChildFrame *)new wxMDIChildFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17428
17429         wxPyEndAllowThreads(__tstate);
17430         if (PyErr_Occurred()) SWIG_fail;
17431     }
17432     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17433     {
17434         if (temp3)
17435         delete arg3;
17436     }
17437     {
17438         if (temp7)
17439         delete arg7;
17440     }
17441     return resultobj;
17442     fail:
17443     {
17444         if (temp3)
17445         delete arg3;
17446     }
17447     {
17448         if (temp7)
17449         delete arg7;
17450     }
17451     return NULL;
17452 }
17453
17454
17455 static PyObject *_wrap_new_PreMDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17456     PyObject *resultobj;
17457     wxMDIChildFrame *result;
17458     char *kwnames[] = {
17459         NULL
17460     };
17461
17462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIChildFrame",kwnames)) goto fail;
17463     {
17464         if (!wxPyCheckForApp()) SWIG_fail;
17465         PyThreadState* __tstate = wxPyBeginAllowThreads();
17466         result = (wxMDIChildFrame *)new wxMDIChildFrame();
17467
17468         wxPyEndAllowThreads(__tstate);
17469         if (PyErr_Occurred()) SWIG_fail;
17470     }
17471     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17472     return resultobj;
17473     fail:
17474     return NULL;
17475 }
17476
17477
17478 static PyObject *_wrap_MDIChildFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17479     PyObject *resultobj;
17480     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17481     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17482     int arg3 = (int) (int)-1 ;
17483     wxString const &arg4_defvalue = wxPyEmptyString ;
17484     wxString *arg4 = (wxString *) &arg4_defvalue ;
17485     wxPoint const &arg5_defvalue = wxDefaultPosition ;
17486     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
17487     wxSize const &arg6_defvalue = wxDefaultSize ;
17488     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
17489     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
17490     wxString const &arg8_defvalue = wxPyFrameNameStr ;
17491     wxString *arg8 = (wxString *) &arg8_defvalue ;
17492     bool result;
17493     bool temp4 = false ;
17494     wxPoint temp5 ;
17495     wxSize temp6 ;
17496     bool temp8 = false ;
17497     PyObject * obj0 = 0 ;
17498     PyObject * obj1 = 0 ;
17499     PyObject * obj2 = 0 ;
17500     PyObject * obj3 = 0 ;
17501     PyObject * obj4 = 0 ;
17502     PyObject * obj5 = 0 ;
17503     PyObject * obj6 = 0 ;
17504     PyObject * obj7 = 0 ;
17505     char *kwnames[] = {
17506         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17507     };
17508
17509     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIChildFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
17510     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17511     if (SWIG_arg_fail(1)) SWIG_fail;
17512     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17513     if (SWIG_arg_fail(2)) SWIG_fail;
17514     if (obj2) {
17515         {
17516             arg3 = (int const)(SWIG_As_int(obj2));
17517             if (SWIG_arg_fail(3)) SWIG_fail;
17518         }
17519     }
17520     if (obj3) {
17521         {
17522             arg4 = wxString_in_helper(obj3);
17523             if (arg4 == NULL) SWIG_fail;
17524             temp4 = true;
17525         }
17526     }
17527     if (obj4) {
17528         {
17529             arg5 = &temp5;
17530             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17531         }
17532     }
17533     if (obj5) {
17534         {
17535             arg6 = &temp6;
17536             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
17537         }
17538     }
17539     if (obj6) {
17540         {
17541             arg7 = (long)(SWIG_As_long(obj6));
17542             if (SWIG_arg_fail(7)) SWIG_fail;
17543         }
17544     }
17545     if (obj7) {
17546         {
17547             arg8 = wxString_in_helper(obj7);
17548             if (arg8 == NULL) SWIG_fail;
17549             temp8 = true;
17550         }
17551     }
17552     {
17553         PyThreadState* __tstate = wxPyBeginAllowThreads();
17554         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17555
17556         wxPyEndAllowThreads(__tstate);
17557         if (PyErr_Occurred()) SWIG_fail;
17558     }
17559     {
17560         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17561     }
17562     {
17563         if (temp4)
17564         delete arg4;
17565     }
17566     {
17567         if (temp8)
17568         delete arg8;
17569     }
17570     return resultobj;
17571     fail:
17572     {
17573         if (temp4)
17574         delete arg4;
17575     }
17576     {
17577         if (temp8)
17578         delete arg8;
17579     }
17580     return NULL;
17581 }
17582
17583
17584 static PyObject *_wrap_MDIChildFrame_Activate(PyObject *, PyObject *args, PyObject *kwargs) {
17585     PyObject *resultobj;
17586     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17587     PyObject * obj0 = 0 ;
17588     char *kwnames[] = {
17589         (char *) "self", NULL
17590     };
17591
17592     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Activate",kwnames,&obj0)) goto fail;
17593     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17594     if (SWIG_arg_fail(1)) SWIG_fail;
17595     {
17596         PyThreadState* __tstate = wxPyBeginAllowThreads();
17597         (arg1)->Activate();
17598
17599         wxPyEndAllowThreads(__tstate);
17600         if (PyErr_Occurred()) SWIG_fail;
17601     }
17602     Py_INCREF(Py_None); resultobj = Py_None;
17603     return resultobj;
17604     fail:
17605     return NULL;
17606 }
17607
17608
17609 static PyObject *_wrap_MDIChildFrame_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
17610     PyObject *resultobj;
17611     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17612     bool arg2 = (bool) true ;
17613     PyObject * obj0 = 0 ;
17614     PyObject * obj1 = 0 ;
17615     char *kwnames[] = {
17616         (char *) "self",(char *) "maximize", NULL
17617     };
17618
17619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIChildFrame_Maximize",kwnames,&obj0,&obj1)) goto fail;
17620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17621     if (SWIG_arg_fail(1)) SWIG_fail;
17622     if (obj1) {
17623         {
17624             arg2 = (bool)(SWIG_As_bool(obj1));
17625             if (SWIG_arg_fail(2)) SWIG_fail;
17626         }
17627     }
17628     {
17629         PyThreadState* __tstate = wxPyBeginAllowThreads();
17630         (arg1)->Maximize(arg2);
17631
17632         wxPyEndAllowThreads(__tstate);
17633         if (PyErr_Occurred()) SWIG_fail;
17634     }
17635     Py_INCREF(Py_None); resultobj = Py_None;
17636     return resultobj;
17637     fail:
17638     return NULL;
17639 }
17640
17641
17642 static PyObject *_wrap_MDIChildFrame_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
17643     PyObject *resultobj;
17644     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17645     PyObject * obj0 = 0 ;
17646     char *kwnames[] = {
17647         (char *) "self", NULL
17648     };
17649
17650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Restore",kwnames,&obj0)) goto fail;
17651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17652     if (SWIG_arg_fail(1)) SWIG_fail;
17653     {
17654         PyThreadState* __tstate = wxPyBeginAllowThreads();
17655         (arg1)->Restore();
17656
17657         wxPyEndAllowThreads(__tstate);
17658         if (PyErr_Occurred()) SWIG_fail;
17659     }
17660     Py_INCREF(Py_None); resultobj = Py_None;
17661     return resultobj;
17662     fail:
17663     return NULL;
17664 }
17665
17666
17667 static PyObject * MDIChildFrame_swigregister(PyObject *, PyObject *args) {
17668     PyObject *obj;
17669     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17670     SWIG_TypeClientData(SWIGTYPE_p_wxMDIChildFrame, obj);
17671     Py_INCREF(obj);
17672     return Py_BuildValue((char *)"");
17673 }
17674 static PyObject *_wrap_new_MDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17675     PyObject *resultobj;
17676     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17677     long arg2 = (long) 0 ;
17678     wxMDIClientWindow *result;
17679     PyObject * obj0 = 0 ;
17680     PyObject * obj1 = 0 ;
17681     char *kwnames[] = {
17682         (char *) "parent",(char *) "style", NULL
17683     };
17684
17685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_MDIClientWindow",kwnames,&obj0,&obj1)) goto fail;
17686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17687     if (SWIG_arg_fail(1)) SWIG_fail;
17688     if (obj1) {
17689         {
17690             arg2 = (long)(SWIG_As_long(obj1));
17691             if (SWIG_arg_fail(2)) SWIG_fail;
17692         }
17693     }
17694     {
17695         if (!wxPyCheckForApp()) SWIG_fail;
17696         PyThreadState* __tstate = wxPyBeginAllowThreads();
17697         result = (wxMDIClientWindow *)new wxMDIClientWindow(arg1,arg2);
17698
17699         wxPyEndAllowThreads(__tstate);
17700         if (PyErr_Occurred()) SWIG_fail;
17701     }
17702     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17703     return resultobj;
17704     fail:
17705     return NULL;
17706 }
17707
17708
17709 static PyObject *_wrap_new_PreMDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17710     PyObject *resultobj;
17711     wxMDIClientWindow *result;
17712     char *kwnames[] = {
17713         NULL
17714     };
17715
17716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIClientWindow",kwnames)) goto fail;
17717     {
17718         if (!wxPyCheckForApp()) SWIG_fail;
17719         PyThreadState* __tstate = wxPyBeginAllowThreads();
17720         result = (wxMDIClientWindow *)new wxMDIClientWindow();
17721
17722         wxPyEndAllowThreads(__tstate);
17723         if (PyErr_Occurred()) SWIG_fail;
17724     }
17725     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17726     return resultobj;
17727     fail:
17728     return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_MDIClientWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17733     PyObject *resultobj;
17734     wxMDIClientWindow *arg1 = (wxMDIClientWindow *) 0 ;
17735     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17736     long arg3 = (long) 0 ;
17737     bool result;
17738     PyObject * obj0 = 0 ;
17739     PyObject * obj1 = 0 ;
17740     PyObject * obj2 = 0 ;
17741     char *kwnames[] = {
17742         (char *) "self",(char *) "parent",(char *) "style", NULL
17743     };
17744
17745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MDIClientWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
17746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIClientWindow, SWIG_POINTER_EXCEPTION | 0);
17747     if (SWIG_arg_fail(1)) SWIG_fail;
17748     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17749     if (SWIG_arg_fail(2)) SWIG_fail;
17750     if (obj2) {
17751         {
17752             arg3 = (long)(SWIG_As_long(obj2));
17753             if (SWIG_arg_fail(3)) SWIG_fail;
17754         }
17755     }
17756     {
17757         PyThreadState* __tstate = wxPyBeginAllowThreads();
17758         result = (bool)(arg1)->Create(arg2,arg3);
17759
17760         wxPyEndAllowThreads(__tstate);
17761         if (PyErr_Occurred()) SWIG_fail;
17762     }
17763     {
17764         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17765     }
17766     return resultobj;
17767     fail:
17768     return NULL;
17769 }
17770
17771
17772 static PyObject * MDIClientWindow_swigregister(PyObject *, PyObject *args) {
17773     PyObject *obj;
17774     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17775     SWIG_TypeClientData(SWIGTYPE_p_wxMDIClientWindow, obj);
17776     Py_INCREF(obj);
17777     return Py_BuildValue((char *)"");
17778 }
17779 static PyObject *_wrap_new_PyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17780     PyObject *resultobj;
17781     wxWindow *arg1 = (wxWindow *) 0 ;
17782     int arg2 = (int) (int)-1 ;
17783     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17784     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17785     wxSize const &arg4_defvalue = wxDefaultSize ;
17786     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17787     long arg5 = (long) 0 ;
17788     wxString const &arg6_defvalue = wxPyPanelNameStr ;
17789     wxString *arg6 = (wxString *) &arg6_defvalue ;
17790     wxPyWindow *result;
17791     wxPoint temp3 ;
17792     wxSize temp4 ;
17793     bool temp6 = false ;
17794     PyObject * obj0 = 0 ;
17795     PyObject * obj1 = 0 ;
17796     PyObject * obj2 = 0 ;
17797     PyObject * obj3 = 0 ;
17798     PyObject * obj4 = 0 ;
17799     PyObject * obj5 = 0 ;
17800     char *kwnames[] = {
17801         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17802     };
17803
17804     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17805     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17806     if (SWIG_arg_fail(1)) SWIG_fail;
17807     if (obj1) {
17808         {
17809             arg2 = (int const)(SWIG_As_int(obj1));
17810             if (SWIG_arg_fail(2)) SWIG_fail;
17811         }
17812     }
17813     if (obj2) {
17814         {
17815             arg3 = &temp3;
17816             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17817         }
17818     }
17819     if (obj3) {
17820         {
17821             arg4 = &temp4;
17822             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17823         }
17824     }
17825     if (obj4) {
17826         {
17827             arg5 = (long)(SWIG_As_long(obj4));
17828             if (SWIG_arg_fail(5)) SWIG_fail;
17829         }
17830     }
17831     if (obj5) {
17832         {
17833             arg6 = wxString_in_helper(obj5);
17834             if (arg6 == NULL) SWIG_fail;
17835             temp6 = true;
17836         }
17837     }
17838     {
17839         if (!wxPyCheckForApp()) SWIG_fail;
17840         PyThreadState* __tstate = wxPyBeginAllowThreads();
17841         result = (wxPyWindow *)new wxPyWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17842
17843         wxPyEndAllowThreads(__tstate);
17844         if (PyErr_Occurred()) SWIG_fail;
17845     }
17846     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17847     {
17848         if (temp6)
17849         delete arg6;
17850     }
17851     return resultobj;
17852     fail:
17853     {
17854         if (temp6)
17855         delete arg6;
17856     }
17857     return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_new_PrePyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17862     PyObject *resultobj;
17863     wxPyWindow *result;
17864     char *kwnames[] = {
17865         NULL
17866     };
17867
17868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyWindow",kwnames)) goto fail;
17869     {
17870         if (!wxPyCheckForApp()) SWIG_fail;
17871         PyThreadState* __tstate = wxPyBeginAllowThreads();
17872         result = (wxPyWindow *)new wxPyWindow();
17873
17874         wxPyEndAllowThreads(__tstate);
17875         if (PyErr_Occurred()) SWIG_fail;
17876     }
17877     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17878     return resultobj;
17879     fail:
17880     return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_PyWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17885     PyObject *resultobj;
17886     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17887     PyObject *arg2 = (PyObject *) 0 ;
17888     PyObject *arg3 = (PyObject *) 0 ;
17889     PyObject * obj0 = 0 ;
17890     PyObject * obj1 = 0 ;
17891     PyObject * obj2 = 0 ;
17892     char *kwnames[] = {
17893         (char *) "self",(char *) "self",(char *) "_class", NULL
17894     };
17895
17896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17898     if (SWIG_arg_fail(1)) SWIG_fail;
17899     arg2 = obj1;
17900     arg3 = obj2;
17901     {
17902         PyThreadState* __tstate = wxPyBeginAllowThreads();
17903         (arg1)->_setCallbackInfo(arg2,arg3);
17904
17905         wxPyEndAllowThreads(__tstate);
17906         if (PyErr_Occurred()) SWIG_fail;
17907     }
17908     Py_INCREF(Py_None); resultobj = Py_None;
17909     return resultobj;
17910     fail:
17911     return NULL;
17912 }
17913
17914
17915 static PyObject *_wrap_PyWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
17916     PyObject *resultobj;
17917     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17918     wxSize *arg2 = 0 ;
17919     wxSize temp2 ;
17920     PyObject * obj0 = 0 ;
17921     PyObject * obj1 = 0 ;
17922     char *kwnames[] = {
17923         (char *) "self",(char *) "size", NULL
17924     };
17925
17926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
17927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17928     if (SWIG_arg_fail(1)) SWIG_fail;
17929     {
17930         arg2 = &temp2;
17931         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17932     }
17933     {
17934         PyThreadState* __tstate = wxPyBeginAllowThreads();
17935         (arg1)->SetBestSize((wxSize const &)*arg2);
17936
17937         wxPyEndAllowThreads(__tstate);
17938         if (PyErr_Occurred()) SWIG_fail;
17939     }
17940     Py_INCREF(Py_None); resultobj = Py_None;
17941     return resultobj;
17942     fail:
17943     return NULL;
17944 }
17945
17946
17947 static PyObject *_wrap_PyWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17948     PyObject *resultobj;
17949     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17950     int arg2 ;
17951     int arg3 ;
17952     int arg4 ;
17953     int arg5 ;
17954     PyObject * obj0 = 0 ;
17955     PyObject * obj1 = 0 ;
17956     PyObject * obj2 = 0 ;
17957     PyObject * obj3 = 0 ;
17958     PyObject * obj4 = 0 ;
17959     char *kwnames[] = {
17960         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17961     };
17962
17963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17965     if (SWIG_arg_fail(1)) SWIG_fail;
17966     {
17967         arg2 = (int)(SWIG_As_int(obj1));
17968         if (SWIG_arg_fail(2)) SWIG_fail;
17969     }
17970     {
17971         arg3 = (int)(SWIG_As_int(obj2));
17972         if (SWIG_arg_fail(3)) SWIG_fail;
17973     }
17974     {
17975         arg4 = (int)(SWIG_As_int(obj3));
17976         if (SWIG_arg_fail(4)) SWIG_fail;
17977     }
17978     {
17979         arg5 = (int)(SWIG_As_int(obj4));
17980         if (SWIG_arg_fail(5)) SWIG_fail;
17981     }
17982     {
17983         PyThreadState* __tstate = wxPyBeginAllowThreads();
17984         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
17985
17986         wxPyEndAllowThreads(__tstate);
17987         if (PyErr_Occurred()) SWIG_fail;
17988     }
17989     Py_INCREF(Py_None); resultobj = Py_None;
17990     return resultobj;
17991     fail:
17992     return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_PyWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17997     PyObject *resultobj;
17998     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17999     int arg2 ;
18000     int arg3 ;
18001     int arg4 ;
18002     int arg5 ;
18003     int arg6 = (int) wxSIZE_AUTO ;
18004     PyObject * obj0 = 0 ;
18005     PyObject * obj1 = 0 ;
18006     PyObject * obj2 = 0 ;
18007     PyObject * obj3 = 0 ;
18008     PyObject * obj4 = 0 ;
18009     PyObject * obj5 = 0 ;
18010     char *kwnames[] = {
18011         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18012     };
18013
18014     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18015     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18016     if (SWIG_arg_fail(1)) SWIG_fail;
18017     {
18018         arg2 = (int)(SWIG_As_int(obj1));
18019         if (SWIG_arg_fail(2)) SWIG_fail;
18020     }
18021     {
18022         arg3 = (int)(SWIG_As_int(obj2));
18023         if (SWIG_arg_fail(3)) SWIG_fail;
18024     }
18025     {
18026         arg4 = (int)(SWIG_As_int(obj3));
18027         if (SWIG_arg_fail(4)) SWIG_fail;
18028     }
18029     {
18030         arg5 = (int)(SWIG_As_int(obj4));
18031         if (SWIG_arg_fail(5)) SWIG_fail;
18032     }
18033     if (obj5) {
18034         {
18035             arg6 = (int)(SWIG_As_int(obj5));
18036             if (SWIG_arg_fail(6)) SWIG_fail;
18037         }
18038     }
18039     {
18040         PyThreadState* __tstate = wxPyBeginAllowThreads();
18041         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18042
18043         wxPyEndAllowThreads(__tstate);
18044         if (PyErr_Occurred()) SWIG_fail;
18045     }
18046     Py_INCREF(Py_None); resultobj = Py_None;
18047     return resultobj;
18048     fail:
18049     return NULL;
18050 }
18051
18052
18053 static PyObject *_wrap_PyWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18054     PyObject *resultobj;
18055     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18056     int arg2 ;
18057     int arg3 ;
18058     PyObject * obj0 = 0 ;
18059     PyObject * obj1 = 0 ;
18060     PyObject * obj2 = 0 ;
18061     char *kwnames[] = {
18062         (char *) "self",(char *) "width",(char *) "height", NULL
18063     };
18064
18065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, 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     {
18073         arg3 = (int)(SWIG_As_int(obj2));
18074         if (SWIG_arg_fail(3)) SWIG_fail;
18075     }
18076     {
18077         PyThreadState* __tstate = wxPyBeginAllowThreads();
18078         (arg1)->base_DoSetClientSize(arg2,arg3);
18079
18080         wxPyEndAllowThreads(__tstate);
18081         if (PyErr_Occurred()) SWIG_fail;
18082     }
18083     Py_INCREF(Py_None); resultobj = Py_None;
18084     return resultobj;
18085     fail:
18086     return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_PyWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18091     PyObject *resultobj;
18092     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18093     int arg2 ;
18094     int arg3 ;
18095     PyObject * obj0 = 0 ;
18096     PyObject * obj1 = 0 ;
18097     PyObject * obj2 = 0 ;
18098     char *kwnames[] = {
18099         (char *) "self",(char *) "x",(char *) "y", NULL
18100     };
18101
18102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18104     if (SWIG_arg_fail(1)) SWIG_fail;
18105     {
18106         arg2 = (int)(SWIG_As_int(obj1));
18107         if (SWIG_arg_fail(2)) SWIG_fail;
18108     }
18109     {
18110         arg3 = (int)(SWIG_As_int(obj2));
18111         if (SWIG_arg_fail(3)) SWIG_fail;
18112     }
18113     {
18114         PyThreadState* __tstate = wxPyBeginAllowThreads();
18115         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18116
18117         wxPyEndAllowThreads(__tstate);
18118         if (PyErr_Occurred()) SWIG_fail;
18119     }
18120     Py_INCREF(Py_None); resultobj = Py_None;
18121     return resultobj;
18122     fail:
18123     return NULL;
18124 }
18125
18126
18127 static PyObject *_wrap_PyWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18128     PyObject *resultobj;
18129     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18130     int *arg2 = (int *) 0 ;
18131     int *arg3 = (int *) 0 ;
18132     int temp2 ;
18133     int res2 = 0 ;
18134     int temp3 ;
18135     int res3 = 0 ;
18136     PyObject * obj0 = 0 ;
18137     char *kwnames[] = {
18138         (char *) "self", NULL
18139     };
18140
18141     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18142     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
18144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18145     if (SWIG_arg_fail(1)) SWIG_fail;
18146     {
18147         PyThreadState* __tstate = wxPyBeginAllowThreads();
18148         ((wxPyWindow const *)arg1)->base_DoGetSize(arg2,arg3);
18149
18150         wxPyEndAllowThreads(__tstate);
18151         if (PyErr_Occurred()) SWIG_fail;
18152     }
18153     Py_INCREF(Py_None); resultobj = Py_None;
18154     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18155     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18156     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18157     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18158     return resultobj;
18159     fail:
18160     return NULL;
18161 }
18162
18163
18164 static PyObject *_wrap_PyWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18165     PyObject *resultobj;
18166     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18167     int *arg2 = (int *) 0 ;
18168     int *arg3 = (int *) 0 ;
18169     int temp2 ;
18170     int res2 = 0 ;
18171     int temp3 ;
18172     int res3 = 0 ;
18173     PyObject * obj0 = 0 ;
18174     char *kwnames[] = {
18175         (char *) "self", NULL
18176     };
18177
18178     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18179     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18182     if (SWIG_arg_fail(1)) SWIG_fail;
18183     {
18184         PyThreadState* __tstate = wxPyBeginAllowThreads();
18185         ((wxPyWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
18186
18187         wxPyEndAllowThreads(__tstate);
18188         if (PyErr_Occurred()) SWIG_fail;
18189     }
18190     Py_INCREF(Py_None); resultobj = Py_None;
18191     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18192     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18193     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18194     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18195     return resultobj;
18196     fail:
18197     return NULL;
18198 }
18199
18200
18201 static PyObject *_wrap_PyWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18202     PyObject *resultobj;
18203     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18204     int *arg2 = (int *) 0 ;
18205     int *arg3 = (int *) 0 ;
18206     int temp2 ;
18207     int res2 = 0 ;
18208     int temp3 ;
18209     int res3 = 0 ;
18210     PyObject * obj0 = 0 ;
18211     char *kwnames[] = {
18212         (char *) "self", NULL
18213     };
18214
18215     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18216     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
18218     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18219     if (SWIG_arg_fail(1)) SWIG_fail;
18220     {
18221         PyThreadState* __tstate = wxPyBeginAllowThreads();
18222         ((wxPyWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
18223
18224         wxPyEndAllowThreads(__tstate);
18225         if (PyErr_Occurred()) SWIG_fail;
18226     }
18227     Py_INCREF(Py_None); resultobj = Py_None;
18228     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18229     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18230     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18231     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18232     return resultobj;
18233     fail:
18234     return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_PyWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18239     PyObject *resultobj;
18240     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18241     wxSize result;
18242     PyObject * obj0 = 0 ;
18243     char *kwnames[] = {
18244         (char *) "self", NULL
18245     };
18246
18247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18248     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18249     if (SWIG_arg_fail(1)) SWIG_fail;
18250     {
18251         PyThreadState* __tstate = wxPyBeginAllowThreads();
18252         result = ((wxPyWindow const *)arg1)->base_DoGetVirtualSize();
18253
18254         wxPyEndAllowThreads(__tstate);
18255         if (PyErr_Occurred()) SWIG_fail;
18256     }
18257     {
18258         wxSize * resultptr;
18259         resultptr = new wxSize((wxSize &)(result));
18260         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18261     }
18262     return resultobj;
18263     fail:
18264     return NULL;
18265 }
18266
18267
18268 static PyObject *_wrap_PyWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18269     PyObject *resultobj;
18270     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18271     wxSize result;
18272     PyObject * obj0 = 0 ;
18273     char *kwnames[] = {
18274         (char *) "self", NULL
18275     };
18276
18277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18279     if (SWIG_arg_fail(1)) SWIG_fail;
18280     {
18281         PyThreadState* __tstate = wxPyBeginAllowThreads();
18282         result = ((wxPyWindow const *)arg1)->base_DoGetBestSize();
18283
18284         wxPyEndAllowThreads(__tstate);
18285         if (PyErr_Occurred()) SWIG_fail;
18286     }
18287     {
18288         wxSize * resultptr;
18289         resultptr = new wxSize((wxSize &)(result));
18290         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18291     }
18292     return resultobj;
18293     fail:
18294     return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_PyWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
18299     PyObject *resultobj;
18300     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18301     PyObject * obj0 = 0 ;
18302     char *kwnames[] = {
18303         (char *) "self", NULL
18304     };
18305
18306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_InitDialog",kwnames,&obj0)) goto fail;
18307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18308     if (SWIG_arg_fail(1)) SWIG_fail;
18309     {
18310         PyThreadState* __tstate = wxPyBeginAllowThreads();
18311         (arg1)->base_InitDialog();
18312
18313         wxPyEndAllowThreads(__tstate);
18314         if (PyErr_Occurred()) SWIG_fail;
18315     }
18316     Py_INCREF(Py_None); resultobj = Py_None;
18317     return resultobj;
18318     fail:
18319     return NULL;
18320 }
18321
18322
18323 static PyObject *_wrap_PyWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18324     PyObject *resultobj;
18325     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18326     bool result;
18327     PyObject * obj0 = 0 ;
18328     char *kwnames[] = {
18329         (char *) "self", NULL
18330     };
18331
18332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
18333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18334     if (SWIG_arg_fail(1)) SWIG_fail;
18335     {
18336         PyThreadState* __tstate = wxPyBeginAllowThreads();
18337         result = (bool)(arg1)->base_TransferDataToWindow();
18338
18339         wxPyEndAllowThreads(__tstate);
18340         if (PyErr_Occurred()) SWIG_fail;
18341     }
18342     {
18343         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18344     }
18345     return resultobj;
18346     fail:
18347     return NULL;
18348 }
18349
18350
18351 static PyObject *_wrap_PyWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18352     PyObject *resultobj;
18353     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18354     bool result;
18355     PyObject * obj0 = 0 ;
18356     char *kwnames[] = {
18357         (char *) "self", NULL
18358     };
18359
18360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
18361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18362     if (SWIG_arg_fail(1)) SWIG_fail;
18363     {
18364         PyThreadState* __tstate = wxPyBeginAllowThreads();
18365         result = (bool)(arg1)->base_TransferDataFromWindow();
18366
18367         wxPyEndAllowThreads(__tstate);
18368         if (PyErr_Occurred()) SWIG_fail;
18369     }
18370     {
18371         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18372     }
18373     return resultobj;
18374     fail:
18375     return NULL;
18376 }
18377
18378
18379 static PyObject *_wrap_PyWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
18380     PyObject *resultobj;
18381     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18382     bool result;
18383     PyObject * obj0 = 0 ;
18384     char *kwnames[] = {
18385         (char *) "self", NULL
18386     };
18387
18388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_Validate",kwnames,&obj0)) goto fail;
18389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18390     if (SWIG_arg_fail(1)) SWIG_fail;
18391     {
18392         PyThreadState* __tstate = wxPyBeginAllowThreads();
18393         result = (bool)(arg1)->base_Validate();
18394
18395         wxPyEndAllowThreads(__tstate);
18396         if (PyErr_Occurred()) SWIG_fail;
18397     }
18398     {
18399         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18400     }
18401     return resultobj;
18402     fail:
18403     return NULL;
18404 }
18405
18406
18407 static PyObject *_wrap_PyWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
18408     PyObject *resultobj;
18409     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18410     bool result;
18411     PyObject * obj0 = 0 ;
18412     char *kwnames[] = {
18413         (char *) "self", NULL
18414     };
18415
18416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
18417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18418     if (SWIG_arg_fail(1)) SWIG_fail;
18419     {
18420         PyThreadState* __tstate = wxPyBeginAllowThreads();
18421         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocus();
18422
18423         wxPyEndAllowThreads(__tstate);
18424         if (PyErr_Occurred()) SWIG_fail;
18425     }
18426     {
18427         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18428     }
18429     return resultobj;
18430     fail:
18431     return NULL;
18432 }
18433
18434
18435 static PyObject *_wrap_PyWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
18436     PyObject *resultobj;
18437     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18438     bool result;
18439     PyObject * obj0 = 0 ;
18440     char *kwnames[] = {
18441         (char *) "self", NULL
18442     };
18443
18444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
18445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18446     if (SWIG_arg_fail(1)) SWIG_fail;
18447     {
18448         PyThreadState* __tstate = wxPyBeginAllowThreads();
18449         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
18450
18451         wxPyEndAllowThreads(__tstate);
18452         if (PyErr_Occurred()) SWIG_fail;
18453     }
18454     {
18455         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18456     }
18457     return resultobj;
18458     fail:
18459     return NULL;
18460 }
18461
18462
18463 static PyObject *_wrap_PyWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
18464     PyObject *resultobj;
18465     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18466     wxSize result;
18467     PyObject * obj0 = 0 ;
18468     char *kwnames[] = {
18469         (char *) "self", NULL
18470     };
18471
18472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
18473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18474     if (SWIG_arg_fail(1)) SWIG_fail;
18475     {
18476         PyThreadState* __tstate = wxPyBeginAllowThreads();
18477         result = ((wxPyWindow const *)arg1)->base_GetMaxSize();
18478
18479         wxPyEndAllowThreads(__tstate);
18480         if (PyErr_Occurred()) SWIG_fail;
18481     }
18482     {
18483         wxSize * resultptr;
18484         resultptr = new wxSize((wxSize &)(result));
18485         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18486     }
18487     return resultobj;
18488     fail:
18489     return NULL;
18490 }
18491
18492
18493 static PyObject *_wrap_PyWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
18494     PyObject *resultobj;
18495     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18496     wxWindow *arg2 = (wxWindow *) 0 ;
18497     PyObject * obj0 = 0 ;
18498     PyObject * obj1 = 0 ;
18499     char *kwnames[] = {
18500         (char *) "self",(char *) "child", NULL
18501     };
18502
18503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
18504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18505     if (SWIG_arg_fail(1)) SWIG_fail;
18506     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18507     if (SWIG_arg_fail(2)) SWIG_fail;
18508     {
18509         PyThreadState* __tstate = wxPyBeginAllowThreads();
18510         (arg1)->base_AddChild(arg2);
18511
18512         wxPyEndAllowThreads(__tstate);
18513         if (PyErr_Occurred()) SWIG_fail;
18514     }
18515     Py_INCREF(Py_None); resultobj = Py_None;
18516     return resultobj;
18517     fail:
18518     return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_PyWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
18523     PyObject *resultobj;
18524     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18525     wxWindow *arg2 = (wxWindow *) 0 ;
18526     PyObject * obj0 = 0 ;
18527     PyObject * obj1 = 0 ;
18528     char *kwnames[] = {
18529         (char *) "self",(char *) "child", NULL
18530     };
18531
18532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
18533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18534     if (SWIG_arg_fail(1)) SWIG_fail;
18535     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18536     if (SWIG_arg_fail(2)) SWIG_fail;
18537     {
18538         PyThreadState* __tstate = wxPyBeginAllowThreads();
18539         (arg1)->base_RemoveChild(arg2);
18540
18541         wxPyEndAllowThreads(__tstate);
18542         if (PyErr_Occurred()) SWIG_fail;
18543     }
18544     Py_INCREF(Py_None); resultobj = Py_None;
18545     return resultobj;
18546     fail:
18547     return NULL;
18548 }
18549
18550
18551 static PyObject *_wrap_PyWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
18552     PyObject *resultobj;
18553     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18554     bool result;
18555     PyObject * obj0 = 0 ;
18556     char *kwnames[] = {
18557         (char *) "self", NULL
18558     };
18559
18560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
18561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18562     if (SWIG_arg_fail(1)) SWIG_fail;
18563     {
18564         PyThreadState* __tstate = wxPyBeginAllowThreads();
18565         result = (bool)((wxPyWindow const *)arg1)->base_ShouldInheritColours();
18566
18567         wxPyEndAllowThreads(__tstate);
18568         if (PyErr_Occurred()) SWIG_fail;
18569     }
18570     {
18571         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18572     }
18573     return resultobj;
18574     fail:
18575     return NULL;
18576 }
18577
18578
18579 static PyObject *_wrap_PyWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
18580     PyObject *resultobj;
18581     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18582     wxColour *arg2 = 0 ;
18583     wxColour temp2 ;
18584     PyObject * obj0 = 0 ;
18585     PyObject * obj1 = 0 ;
18586     char *kwnames[] = {
18587         (char *) "self",(char *) "c", NULL
18588     };
18589
18590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
18591     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18592     if (SWIG_arg_fail(1)) SWIG_fail;
18593     {
18594         arg2 = &temp2;
18595         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18596     }
18597     {
18598         PyThreadState* __tstate = wxPyBeginAllowThreads();
18599         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
18600
18601         wxPyEndAllowThreads(__tstate);
18602         if (PyErr_Occurred()) SWIG_fail;
18603     }
18604     Py_INCREF(Py_None); resultobj = Py_None;
18605     return resultobj;
18606     fail:
18607     return NULL;
18608 }
18609
18610
18611 static PyObject *_wrap_PyWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
18612     PyObject *resultobj;
18613     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18614     wxVisualAttributes result;
18615     PyObject * obj0 = 0 ;
18616     char *kwnames[] = {
18617         (char *) "self", NULL
18618     };
18619
18620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
18621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18622     if (SWIG_arg_fail(1)) SWIG_fail;
18623     {
18624         PyThreadState* __tstate = wxPyBeginAllowThreads();
18625         result = (arg1)->base_GetDefaultAttributes();
18626
18627         wxPyEndAllowThreads(__tstate);
18628         if (PyErr_Occurred()) SWIG_fail;
18629     }
18630     {
18631         wxVisualAttributes * resultptr;
18632         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
18633         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
18634     }
18635     return resultobj;
18636     fail:
18637     return NULL;
18638 }
18639
18640
18641 static PyObject * PyWindow_swigregister(PyObject *, PyObject *args) {
18642     PyObject *obj;
18643     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18644     SWIG_TypeClientData(SWIGTYPE_p_wxPyWindow, obj);
18645     Py_INCREF(obj);
18646     return Py_BuildValue((char *)"");
18647 }
18648 static PyObject *_wrap_new_PyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18649     PyObject *resultobj;
18650     wxWindow *arg1 = (wxWindow *) 0 ;
18651     int arg2 = (int) (int)-1 ;
18652     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18653     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18654     wxSize const &arg4_defvalue = wxDefaultSize ;
18655     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18656     long arg5 = (long) 0 ;
18657     wxString const &arg6_defvalue = wxPyPanelNameStr ;
18658     wxString *arg6 = (wxString *) &arg6_defvalue ;
18659     wxPyPanel *result;
18660     wxPoint temp3 ;
18661     wxSize temp4 ;
18662     bool temp6 = false ;
18663     PyObject * obj0 = 0 ;
18664     PyObject * obj1 = 0 ;
18665     PyObject * obj2 = 0 ;
18666     PyObject * obj3 = 0 ;
18667     PyObject * obj4 = 0 ;
18668     PyObject * obj5 = 0 ;
18669     char *kwnames[] = {
18670         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18671     };
18672
18673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyPanel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18674     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18675     if (SWIG_arg_fail(1)) SWIG_fail;
18676     if (obj1) {
18677         {
18678             arg2 = (int const)(SWIG_As_int(obj1));
18679             if (SWIG_arg_fail(2)) SWIG_fail;
18680         }
18681     }
18682     if (obj2) {
18683         {
18684             arg3 = &temp3;
18685             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18686         }
18687     }
18688     if (obj3) {
18689         {
18690             arg4 = &temp4;
18691             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18692         }
18693     }
18694     if (obj4) {
18695         {
18696             arg5 = (long)(SWIG_As_long(obj4));
18697             if (SWIG_arg_fail(5)) SWIG_fail;
18698         }
18699     }
18700     if (obj5) {
18701         {
18702             arg6 = wxString_in_helper(obj5);
18703             if (arg6 == NULL) SWIG_fail;
18704             temp6 = true;
18705         }
18706     }
18707     {
18708         if (!wxPyCheckForApp()) SWIG_fail;
18709         PyThreadState* __tstate = wxPyBeginAllowThreads();
18710         result = (wxPyPanel *)new wxPyPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18711
18712         wxPyEndAllowThreads(__tstate);
18713         if (PyErr_Occurred()) SWIG_fail;
18714     }
18715     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18716     {
18717         if (temp6)
18718         delete arg6;
18719     }
18720     return resultobj;
18721     fail:
18722     {
18723         if (temp6)
18724         delete arg6;
18725     }
18726     return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_new_PrePyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18731     PyObject *resultobj;
18732     wxPyPanel *result;
18733     char *kwnames[] = {
18734         NULL
18735     };
18736
18737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyPanel",kwnames)) goto fail;
18738     {
18739         if (!wxPyCheckForApp()) SWIG_fail;
18740         PyThreadState* __tstate = wxPyBeginAllowThreads();
18741         result = (wxPyPanel *)new wxPyPanel();
18742
18743         wxPyEndAllowThreads(__tstate);
18744         if (PyErr_Occurred()) SWIG_fail;
18745     }
18746     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18747     return resultobj;
18748     fail:
18749     return NULL;
18750 }
18751
18752
18753 static PyObject *_wrap_PyPanel__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
18754     PyObject *resultobj;
18755     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18756     PyObject *arg2 = (PyObject *) 0 ;
18757     PyObject *arg3 = (PyObject *) 0 ;
18758     PyObject * obj0 = 0 ;
18759     PyObject * obj1 = 0 ;
18760     PyObject * obj2 = 0 ;
18761     char *kwnames[] = {
18762         (char *) "self",(char *) "self",(char *) "_class", NULL
18763     };
18764
18765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
18766     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18767     if (SWIG_arg_fail(1)) SWIG_fail;
18768     arg2 = obj1;
18769     arg3 = obj2;
18770     {
18771         PyThreadState* __tstate = wxPyBeginAllowThreads();
18772         (arg1)->_setCallbackInfo(arg2,arg3);
18773
18774         wxPyEndAllowThreads(__tstate);
18775         if (PyErr_Occurred()) SWIG_fail;
18776     }
18777     Py_INCREF(Py_None); resultobj = Py_None;
18778     return resultobj;
18779     fail:
18780     return NULL;
18781 }
18782
18783
18784 static PyObject *_wrap_PyPanel_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18785     PyObject *resultobj;
18786     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18787     wxSize *arg2 = 0 ;
18788     wxSize temp2 ;
18789     PyObject * obj0 = 0 ;
18790     PyObject * obj1 = 0 ;
18791     char *kwnames[] = {
18792         (char *) "self",(char *) "size", NULL
18793     };
18794
18795     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
18796     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18797     if (SWIG_arg_fail(1)) SWIG_fail;
18798     {
18799         arg2 = &temp2;
18800         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18801     }
18802     {
18803         PyThreadState* __tstate = wxPyBeginAllowThreads();
18804         (arg1)->SetBestSize((wxSize const &)*arg2);
18805
18806         wxPyEndAllowThreads(__tstate);
18807         if (PyErr_Occurred()) SWIG_fail;
18808     }
18809     Py_INCREF(Py_None); resultobj = Py_None;
18810     return resultobj;
18811     fail:
18812     return NULL;
18813 }
18814
18815
18816 static PyObject *_wrap_PyPanel_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18817     PyObject *resultobj;
18818     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18819     int arg2 ;
18820     int arg3 ;
18821     int arg4 ;
18822     int arg5 ;
18823     PyObject * obj0 = 0 ;
18824     PyObject * obj1 = 0 ;
18825     PyObject * obj2 = 0 ;
18826     PyObject * obj3 = 0 ;
18827     PyObject * obj4 = 0 ;
18828     char *kwnames[] = {
18829         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18830     };
18831
18832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyPanel_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18834     if (SWIG_arg_fail(1)) SWIG_fail;
18835     {
18836         arg2 = (int)(SWIG_As_int(obj1));
18837         if (SWIG_arg_fail(2)) SWIG_fail;
18838     }
18839     {
18840         arg3 = (int)(SWIG_As_int(obj2));
18841         if (SWIG_arg_fail(3)) SWIG_fail;
18842     }
18843     {
18844         arg4 = (int)(SWIG_As_int(obj3));
18845         if (SWIG_arg_fail(4)) SWIG_fail;
18846     }
18847     {
18848         arg5 = (int)(SWIG_As_int(obj4));
18849         if (SWIG_arg_fail(5)) SWIG_fail;
18850     }
18851     {
18852         PyThreadState* __tstate = wxPyBeginAllowThreads();
18853         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
18854
18855         wxPyEndAllowThreads(__tstate);
18856         if (PyErr_Occurred()) SWIG_fail;
18857     }
18858     Py_INCREF(Py_None); resultobj = Py_None;
18859     return resultobj;
18860     fail:
18861     return NULL;
18862 }
18863
18864
18865 static PyObject *_wrap_PyPanel_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18866     PyObject *resultobj;
18867     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18868     int arg2 ;
18869     int arg3 ;
18870     int arg4 ;
18871     int arg5 ;
18872     int arg6 = (int) wxSIZE_AUTO ;
18873     PyObject * obj0 = 0 ;
18874     PyObject * obj1 = 0 ;
18875     PyObject * obj2 = 0 ;
18876     PyObject * obj3 = 0 ;
18877     PyObject * obj4 = 0 ;
18878     PyObject * obj5 = 0 ;
18879     char *kwnames[] = {
18880         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18881     };
18882
18883     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyPanel_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18884     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18885     if (SWIG_arg_fail(1)) SWIG_fail;
18886     {
18887         arg2 = (int)(SWIG_As_int(obj1));
18888         if (SWIG_arg_fail(2)) SWIG_fail;
18889     }
18890     {
18891         arg3 = (int)(SWIG_As_int(obj2));
18892         if (SWIG_arg_fail(3)) SWIG_fail;
18893     }
18894     {
18895         arg4 = (int)(SWIG_As_int(obj3));
18896         if (SWIG_arg_fail(4)) SWIG_fail;
18897     }
18898     {
18899         arg5 = (int)(SWIG_As_int(obj4));
18900         if (SWIG_arg_fail(5)) SWIG_fail;
18901     }
18902     if (obj5) {
18903         {
18904             arg6 = (int)(SWIG_As_int(obj5));
18905             if (SWIG_arg_fail(6)) SWIG_fail;
18906         }
18907     }
18908     {
18909         PyThreadState* __tstate = wxPyBeginAllowThreads();
18910         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18911
18912         wxPyEndAllowThreads(__tstate);
18913         if (PyErr_Occurred()) SWIG_fail;
18914     }
18915     Py_INCREF(Py_None); resultobj = Py_None;
18916     return resultobj;
18917     fail:
18918     return NULL;
18919 }
18920
18921
18922 static PyObject *_wrap_PyPanel_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18923     PyObject *resultobj;
18924     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18925     int arg2 ;
18926     int arg3 ;
18927     PyObject * obj0 = 0 ;
18928     PyObject * obj1 = 0 ;
18929     PyObject * obj2 = 0 ;
18930     char *kwnames[] = {
18931         (char *) "self",(char *) "width",(char *) "height", NULL
18932     };
18933
18934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18936     if (SWIG_arg_fail(1)) SWIG_fail;
18937     {
18938         arg2 = (int)(SWIG_As_int(obj1));
18939         if (SWIG_arg_fail(2)) SWIG_fail;
18940     }
18941     {
18942         arg3 = (int)(SWIG_As_int(obj2));
18943         if (SWIG_arg_fail(3)) SWIG_fail;
18944     }
18945     {
18946         PyThreadState* __tstate = wxPyBeginAllowThreads();
18947         (arg1)->base_DoSetClientSize(arg2,arg3);
18948
18949         wxPyEndAllowThreads(__tstate);
18950         if (PyErr_Occurred()) SWIG_fail;
18951     }
18952     Py_INCREF(Py_None); resultobj = Py_None;
18953     return resultobj;
18954     fail:
18955     return NULL;
18956 }
18957
18958
18959 static PyObject *_wrap_PyPanel_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18960     PyObject *resultobj;
18961     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18962     int arg2 ;
18963     int arg3 ;
18964     PyObject * obj0 = 0 ;
18965     PyObject * obj1 = 0 ;
18966     PyObject * obj2 = 0 ;
18967     char *kwnames[] = {
18968         (char *) "self",(char *) "x",(char *) "y", NULL
18969     };
18970
18971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18973     if (SWIG_arg_fail(1)) SWIG_fail;
18974     {
18975         arg2 = (int)(SWIG_As_int(obj1));
18976         if (SWIG_arg_fail(2)) SWIG_fail;
18977     }
18978     {
18979         arg3 = (int)(SWIG_As_int(obj2));
18980         if (SWIG_arg_fail(3)) SWIG_fail;
18981     }
18982     {
18983         PyThreadState* __tstate = wxPyBeginAllowThreads();
18984         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18985
18986         wxPyEndAllowThreads(__tstate);
18987         if (PyErr_Occurred()) SWIG_fail;
18988     }
18989     Py_INCREF(Py_None); resultobj = Py_None;
18990     return resultobj;
18991     fail:
18992     return NULL;
18993 }
18994
18995
18996 static PyObject *_wrap_PyPanel_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18997     PyObject *resultobj;
18998     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18999     int *arg2 = (int *) 0 ;
19000     int *arg3 = (int *) 0 ;
19001     int temp2 ;
19002     int res2 = 0 ;
19003     int temp3 ;
19004     int res3 = 0 ;
19005     PyObject * obj0 = 0 ;
19006     char *kwnames[] = {
19007         (char *) "self", NULL
19008     };
19009
19010     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19011     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetSize",kwnames,&obj0)) goto fail;
19013     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19014     if (SWIG_arg_fail(1)) SWIG_fail;
19015     {
19016         PyThreadState* __tstate = wxPyBeginAllowThreads();
19017         ((wxPyPanel const *)arg1)->base_DoGetSize(arg2,arg3);
19018
19019         wxPyEndAllowThreads(__tstate);
19020         if (PyErr_Occurred()) SWIG_fail;
19021     }
19022     Py_INCREF(Py_None); resultobj = Py_None;
19023     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19024     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19025     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19026     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19027     return resultobj;
19028     fail:
19029     return NULL;
19030 }
19031
19032
19033 static PyObject *_wrap_PyPanel_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19034     PyObject *resultobj;
19035     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19036     int *arg2 = (int *) 0 ;
19037     int *arg3 = (int *) 0 ;
19038     int temp2 ;
19039     int res2 = 0 ;
19040     int temp3 ;
19041     int res3 = 0 ;
19042     PyObject * obj0 = 0 ;
19043     char *kwnames[] = {
19044         (char *) "self", NULL
19045     };
19046
19047     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19048     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19050     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19051     if (SWIG_arg_fail(1)) SWIG_fail;
19052     {
19053         PyThreadState* __tstate = wxPyBeginAllowThreads();
19054         ((wxPyPanel const *)arg1)->base_DoGetClientSize(arg2,arg3);
19055
19056         wxPyEndAllowThreads(__tstate);
19057         if (PyErr_Occurred()) SWIG_fail;
19058     }
19059     Py_INCREF(Py_None); resultobj = Py_None;
19060     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19061     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19062     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19063     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19064     return resultobj;
19065     fail:
19066     return NULL;
19067 }
19068
19069
19070 static PyObject *_wrap_PyPanel_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19071     PyObject *resultobj;
19072     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19073     int *arg2 = (int *) 0 ;
19074     int *arg3 = (int *) 0 ;
19075     int temp2 ;
19076     int res2 = 0 ;
19077     int temp3 ;
19078     int res3 = 0 ;
19079     PyObject * obj0 = 0 ;
19080     char *kwnames[] = {
19081         (char *) "self", NULL
19082     };
19083
19084     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19085     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19086     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetPosition",kwnames,&obj0)) goto fail;
19087     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19088     if (SWIG_arg_fail(1)) SWIG_fail;
19089     {
19090         PyThreadState* __tstate = wxPyBeginAllowThreads();
19091         ((wxPyPanel const *)arg1)->base_DoGetPosition(arg2,arg3);
19092
19093         wxPyEndAllowThreads(__tstate);
19094         if (PyErr_Occurred()) SWIG_fail;
19095     }
19096     Py_INCREF(Py_None); resultobj = Py_None;
19097     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19098     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19099     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19100     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19101     return resultobj;
19102     fail:
19103     return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_PyPanel_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19108     PyObject *resultobj;
19109     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19110     wxSize result;
19111     PyObject * obj0 = 0 ;
19112     char *kwnames[] = {
19113         (char *) "self", NULL
19114     };
19115
19116     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19117     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19118     if (SWIG_arg_fail(1)) SWIG_fail;
19119     {
19120         PyThreadState* __tstate = wxPyBeginAllowThreads();
19121         result = ((wxPyPanel const *)arg1)->base_DoGetVirtualSize();
19122
19123         wxPyEndAllowThreads(__tstate);
19124         if (PyErr_Occurred()) SWIG_fail;
19125     }
19126     {
19127         wxSize * resultptr;
19128         resultptr = new wxSize((wxSize &)(result));
19129         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19130     }
19131     return resultobj;
19132     fail:
19133     return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_PyPanel_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19138     PyObject *resultobj;
19139     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19140     wxSize result;
19141     PyObject * obj0 = 0 ;
19142     char *kwnames[] = {
19143         (char *) "self", NULL
19144     };
19145
19146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetBestSize",kwnames,&obj0)) goto fail;
19147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19148     if (SWIG_arg_fail(1)) SWIG_fail;
19149     {
19150         PyThreadState* __tstate = wxPyBeginAllowThreads();
19151         result = ((wxPyPanel const *)arg1)->base_DoGetBestSize();
19152
19153         wxPyEndAllowThreads(__tstate);
19154         if (PyErr_Occurred()) SWIG_fail;
19155     }
19156     {
19157         wxSize * resultptr;
19158         resultptr = new wxSize((wxSize &)(result));
19159         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19160     }
19161     return resultobj;
19162     fail:
19163     return NULL;
19164 }
19165
19166
19167 static PyObject *_wrap_PyPanel_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19168     PyObject *resultobj;
19169     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19170     PyObject * obj0 = 0 ;
19171     char *kwnames[] = {
19172         (char *) "self", NULL
19173     };
19174
19175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_InitDialog",kwnames,&obj0)) goto fail;
19176     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19177     if (SWIG_arg_fail(1)) SWIG_fail;
19178     {
19179         PyThreadState* __tstate = wxPyBeginAllowThreads();
19180         (arg1)->base_InitDialog();
19181
19182         wxPyEndAllowThreads(__tstate);
19183         if (PyErr_Occurred()) SWIG_fail;
19184     }
19185     Py_INCREF(Py_None); resultobj = Py_None;
19186     return resultobj;
19187     fail:
19188     return NULL;
19189 }
19190
19191
19192 static PyObject *_wrap_PyPanel_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19193     PyObject *resultobj;
19194     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19195     bool result;
19196     PyObject * obj0 = 0 ;
19197     char *kwnames[] = {
19198         (char *) "self", NULL
19199     };
19200
19201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19202     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19203     if (SWIG_arg_fail(1)) SWIG_fail;
19204     {
19205         PyThreadState* __tstate = wxPyBeginAllowThreads();
19206         result = (bool)(arg1)->base_TransferDataToWindow();
19207
19208         wxPyEndAllowThreads(__tstate);
19209         if (PyErr_Occurred()) SWIG_fail;
19210     }
19211     {
19212         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19213     }
19214     return resultobj;
19215     fail:
19216     return NULL;
19217 }
19218
19219
19220 static PyObject *_wrap_PyPanel_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19221     PyObject *resultobj;
19222     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19223     bool result;
19224     PyObject * obj0 = 0 ;
19225     char *kwnames[] = {
19226         (char *) "self", NULL
19227     };
19228
19229     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19230     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19231     if (SWIG_arg_fail(1)) SWIG_fail;
19232     {
19233         PyThreadState* __tstate = wxPyBeginAllowThreads();
19234         result = (bool)(arg1)->base_TransferDataFromWindow();
19235
19236         wxPyEndAllowThreads(__tstate);
19237         if (PyErr_Occurred()) SWIG_fail;
19238     }
19239     {
19240         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19241     }
19242     return resultobj;
19243     fail:
19244     return NULL;
19245 }
19246
19247
19248 static PyObject *_wrap_PyPanel_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19249     PyObject *resultobj;
19250     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19251     bool result;
19252     PyObject * obj0 = 0 ;
19253     char *kwnames[] = {
19254         (char *) "self", NULL
19255     };
19256
19257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_Validate",kwnames,&obj0)) goto fail;
19258     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19259     if (SWIG_arg_fail(1)) SWIG_fail;
19260     {
19261         PyThreadState* __tstate = wxPyBeginAllowThreads();
19262         result = (bool)(arg1)->base_Validate();
19263
19264         wxPyEndAllowThreads(__tstate);
19265         if (PyErr_Occurred()) SWIG_fail;
19266     }
19267     {
19268         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19269     }
19270     return resultobj;
19271     fail:
19272     return NULL;
19273 }
19274
19275
19276 static PyObject *_wrap_PyPanel_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19277     PyObject *resultobj;
19278     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19279     bool result;
19280     PyObject * obj0 = 0 ;
19281     char *kwnames[] = {
19282         (char *) "self", NULL
19283     };
19284
19285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19287     if (SWIG_arg_fail(1)) SWIG_fail;
19288     {
19289         PyThreadState* __tstate = wxPyBeginAllowThreads();
19290         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocus();
19291
19292         wxPyEndAllowThreads(__tstate);
19293         if (PyErr_Occurred()) SWIG_fail;
19294     }
19295     {
19296         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19297     }
19298     return resultobj;
19299     fail:
19300     return NULL;
19301 }
19302
19303
19304 static PyObject *_wrap_PyPanel_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
19305     PyObject *resultobj;
19306     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19307     bool result;
19308     PyObject * obj0 = 0 ;
19309     char *kwnames[] = {
19310         (char *) "self", NULL
19311     };
19312
19313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
19314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19315     if (SWIG_arg_fail(1)) SWIG_fail;
19316     {
19317         PyThreadState* __tstate = wxPyBeginAllowThreads();
19318         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocusFromKeyboard();
19319
19320         wxPyEndAllowThreads(__tstate);
19321         if (PyErr_Occurred()) SWIG_fail;
19322     }
19323     {
19324         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19325     }
19326     return resultobj;
19327     fail:
19328     return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_PyPanel_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
19333     PyObject *resultobj;
19334     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19335     wxSize result;
19336     PyObject * obj0 = 0 ;
19337     char *kwnames[] = {
19338         (char *) "self", NULL
19339     };
19340
19341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetMaxSize",kwnames,&obj0)) goto fail;
19342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19343     if (SWIG_arg_fail(1)) SWIG_fail;
19344     {
19345         PyThreadState* __tstate = wxPyBeginAllowThreads();
19346         result = ((wxPyPanel const *)arg1)->base_GetMaxSize();
19347
19348         wxPyEndAllowThreads(__tstate);
19349         if (PyErr_Occurred()) SWIG_fail;
19350     }
19351     {
19352         wxSize * resultptr;
19353         resultptr = new wxSize((wxSize &)(result));
19354         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19355     }
19356     return resultobj;
19357     fail:
19358     return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_PyPanel_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
19363     PyObject *resultobj;
19364     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19365     wxWindow *arg2 = (wxWindow *) 0 ;
19366     PyObject * obj0 = 0 ;
19367     PyObject * obj1 = 0 ;
19368     char *kwnames[] = {
19369         (char *) "self",(char *) "child", NULL
19370     };
19371
19372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
19373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19374     if (SWIG_arg_fail(1)) SWIG_fail;
19375     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19376     if (SWIG_arg_fail(2)) SWIG_fail;
19377     {
19378         PyThreadState* __tstate = wxPyBeginAllowThreads();
19379         (arg1)->base_AddChild(arg2);
19380
19381         wxPyEndAllowThreads(__tstate);
19382         if (PyErr_Occurred()) SWIG_fail;
19383     }
19384     Py_INCREF(Py_None); resultobj = Py_None;
19385     return resultobj;
19386     fail:
19387     return NULL;
19388 }
19389
19390
19391 static PyObject *_wrap_PyPanel_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
19392     PyObject *resultobj;
19393     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19394     wxWindow *arg2 = (wxWindow *) 0 ;
19395     PyObject * obj0 = 0 ;
19396     PyObject * obj1 = 0 ;
19397     char *kwnames[] = {
19398         (char *) "self",(char *) "child", NULL
19399     };
19400
19401     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
19402     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19403     if (SWIG_arg_fail(1)) SWIG_fail;
19404     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19405     if (SWIG_arg_fail(2)) SWIG_fail;
19406     {
19407         PyThreadState* __tstate = wxPyBeginAllowThreads();
19408         (arg1)->base_RemoveChild(arg2);
19409
19410         wxPyEndAllowThreads(__tstate);
19411         if (PyErr_Occurred()) SWIG_fail;
19412     }
19413     Py_INCREF(Py_None); resultobj = Py_None;
19414     return resultobj;
19415     fail:
19416     return NULL;
19417 }
19418
19419
19420 static PyObject *_wrap_PyPanel_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
19421     PyObject *resultobj;
19422     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19423     bool result;
19424     PyObject * obj0 = 0 ;
19425     char *kwnames[] = {
19426         (char *) "self", NULL
19427     };
19428
19429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
19430     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19431     if (SWIG_arg_fail(1)) SWIG_fail;
19432     {
19433         PyThreadState* __tstate = wxPyBeginAllowThreads();
19434         result = (bool)((wxPyPanel const *)arg1)->base_ShouldInheritColours();
19435
19436         wxPyEndAllowThreads(__tstate);
19437         if (PyErr_Occurred()) SWIG_fail;
19438     }
19439     {
19440         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19441     }
19442     return resultobj;
19443     fail:
19444     return NULL;
19445 }
19446
19447
19448 static PyObject *_wrap_PyPanel_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
19449     PyObject *resultobj;
19450     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19451     wxColour *arg2 = 0 ;
19452     wxColour temp2 ;
19453     PyObject * obj0 = 0 ;
19454     PyObject * obj1 = 0 ;
19455     char *kwnames[] = {
19456         (char *) "self",(char *) "c", NULL
19457     };
19458
19459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
19460     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19461     if (SWIG_arg_fail(1)) SWIG_fail;
19462     {
19463         arg2 = &temp2;
19464         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19465     }
19466     {
19467         PyThreadState* __tstate = wxPyBeginAllowThreads();
19468         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
19469
19470         wxPyEndAllowThreads(__tstate);
19471         if (PyErr_Occurred()) SWIG_fail;
19472     }
19473     Py_INCREF(Py_None); resultobj = Py_None;
19474     return resultobj;
19475     fail:
19476     return NULL;
19477 }
19478
19479
19480 static PyObject *_wrap_PyPanel_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
19481     PyObject *resultobj;
19482     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19483     wxVisualAttributes result;
19484     PyObject * obj0 = 0 ;
19485     char *kwnames[] = {
19486         (char *) "self", NULL
19487     };
19488
19489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
19490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19491     if (SWIG_arg_fail(1)) SWIG_fail;
19492     {
19493         PyThreadState* __tstate = wxPyBeginAllowThreads();
19494         result = (arg1)->base_GetDefaultAttributes();
19495
19496         wxPyEndAllowThreads(__tstate);
19497         if (PyErr_Occurred()) SWIG_fail;
19498     }
19499     {
19500         wxVisualAttributes * resultptr;
19501         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
19502         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
19503     }
19504     return resultobj;
19505     fail:
19506     return NULL;
19507 }
19508
19509
19510 static PyObject * PyPanel_swigregister(PyObject *, PyObject *args) {
19511     PyObject *obj;
19512     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19513     SWIG_TypeClientData(SWIGTYPE_p_wxPyPanel, obj);
19514     Py_INCREF(obj);
19515     return Py_BuildValue((char *)"");
19516 }
19517 static PyObject *_wrap_new_PyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19518     PyObject *resultobj;
19519     wxWindow *arg1 = (wxWindow *) 0 ;
19520     int arg2 = (int) (int)-1 ;
19521     wxPoint const &arg3_defvalue = wxDefaultPosition ;
19522     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
19523     wxSize const &arg4_defvalue = wxDefaultSize ;
19524     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
19525     long arg5 = (long) 0 ;
19526     wxString const &arg6_defvalue = wxPyPanelNameStr ;
19527     wxString *arg6 = (wxString *) &arg6_defvalue ;
19528     wxPyScrolledWindow *result;
19529     wxPoint temp3 ;
19530     wxSize temp4 ;
19531     bool temp6 = false ;
19532     PyObject * obj0 = 0 ;
19533     PyObject * obj1 = 0 ;
19534     PyObject * obj2 = 0 ;
19535     PyObject * obj3 = 0 ;
19536     PyObject * obj4 = 0 ;
19537     PyObject * obj5 = 0 ;
19538     char *kwnames[] = {
19539         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
19540     };
19541
19542     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19543     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19544     if (SWIG_arg_fail(1)) SWIG_fail;
19545     if (obj1) {
19546         {
19547             arg2 = (int const)(SWIG_As_int(obj1));
19548             if (SWIG_arg_fail(2)) SWIG_fail;
19549         }
19550     }
19551     if (obj2) {
19552         {
19553             arg3 = &temp3;
19554             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19555         }
19556     }
19557     if (obj3) {
19558         {
19559             arg4 = &temp4;
19560             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
19561         }
19562     }
19563     if (obj4) {
19564         {
19565             arg5 = (long)(SWIG_As_long(obj4));
19566             if (SWIG_arg_fail(5)) SWIG_fail;
19567         }
19568     }
19569     if (obj5) {
19570         {
19571             arg6 = wxString_in_helper(obj5);
19572             if (arg6 == NULL) SWIG_fail;
19573             temp6 = true;
19574         }
19575     }
19576     {
19577         if (!wxPyCheckForApp()) SWIG_fail;
19578         PyThreadState* __tstate = wxPyBeginAllowThreads();
19579         result = (wxPyScrolledWindow *)new wxPyScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
19580
19581         wxPyEndAllowThreads(__tstate);
19582         if (PyErr_Occurred()) SWIG_fail;
19583     }
19584     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19585     {
19586         if (temp6)
19587         delete arg6;
19588     }
19589     return resultobj;
19590     fail:
19591     {
19592         if (temp6)
19593         delete arg6;
19594     }
19595     return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_new_PrePyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19600     PyObject *resultobj;
19601     wxPyScrolledWindow *result;
19602     char *kwnames[] = {
19603         NULL
19604     };
19605
19606     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyScrolledWindow",kwnames)) goto fail;
19607     {
19608         if (!wxPyCheckForApp()) SWIG_fail;
19609         PyThreadState* __tstate = wxPyBeginAllowThreads();
19610         result = (wxPyScrolledWindow *)new wxPyScrolledWindow();
19611
19612         wxPyEndAllowThreads(__tstate);
19613         if (PyErr_Occurred()) SWIG_fail;
19614     }
19615     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19616     return resultobj;
19617     fail:
19618     return NULL;
19619 }
19620
19621
19622 static PyObject *_wrap_PyScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
19623     PyObject *resultobj;
19624     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19625     PyObject *arg2 = (PyObject *) 0 ;
19626     PyObject *arg3 = (PyObject *) 0 ;
19627     PyObject * obj0 = 0 ;
19628     PyObject * obj1 = 0 ;
19629     PyObject * obj2 = 0 ;
19630     char *kwnames[] = {
19631         (char *) "self",(char *) "self",(char *) "_class", NULL
19632     };
19633
19634     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
19635     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19636     if (SWIG_arg_fail(1)) SWIG_fail;
19637     arg2 = obj1;
19638     arg3 = obj2;
19639     {
19640         PyThreadState* __tstate = wxPyBeginAllowThreads();
19641         (arg1)->_setCallbackInfo(arg2,arg3);
19642
19643         wxPyEndAllowThreads(__tstate);
19644         if (PyErr_Occurred()) SWIG_fail;
19645     }
19646     Py_INCREF(Py_None); resultobj = Py_None;
19647     return resultobj;
19648     fail:
19649     return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_PyScrolledWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19654     PyObject *resultobj;
19655     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19656     wxSize *arg2 = 0 ;
19657     wxSize temp2 ;
19658     PyObject * obj0 = 0 ;
19659     PyObject * obj1 = 0 ;
19660     char *kwnames[] = {
19661         (char *) "self",(char *) "size", NULL
19662     };
19663
19664     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
19665     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19666     if (SWIG_arg_fail(1)) SWIG_fail;
19667     {
19668         arg2 = &temp2;
19669         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
19670     }
19671     {
19672         PyThreadState* __tstate = wxPyBeginAllowThreads();
19673         (arg1)->SetBestSize((wxSize const &)*arg2);
19674
19675         wxPyEndAllowThreads(__tstate);
19676         if (PyErr_Occurred()) SWIG_fail;
19677     }
19678     Py_INCREF(Py_None); resultobj = Py_None;
19679     return resultobj;
19680     fail:
19681     return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_PyScrolledWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19686     PyObject *resultobj;
19687     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19688     int arg2 ;
19689     int arg3 ;
19690     int arg4 ;
19691     int arg5 ;
19692     PyObject * obj0 = 0 ;
19693     PyObject * obj1 = 0 ;
19694     PyObject * obj2 = 0 ;
19695     PyObject * obj3 = 0 ;
19696     PyObject * obj4 = 0 ;
19697     char *kwnames[] = {
19698         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19699     };
19700
19701     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyScrolledWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19702     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19703     if (SWIG_arg_fail(1)) SWIG_fail;
19704     {
19705         arg2 = (int)(SWIG_As_int(obj1));
19706         if (SWIG_arg_fail(2)) SWIG_fail;
19707     }
19708     {
19709         arg3 = (int)(SWIG_As_int(obj2));
19710         if (SWIG_arg_fail(3)) SWIG_fail;
19711     }
19712     {
19713         arg4 = (int)(SWIG_As_int(obj3));
19714         if (SWIG_arg_fail(4)) SWIG_fail;
19715     }
19716     {
19717         arg5 = (int)(SWIG_As_int(obj4));
19718         if (SWIG_arg_fail(5)) SWIG_fail;
19719     }
19720     {
19721         PyThreadState* __tstate = wxPyBeginAllowThreads();
19722         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
19723
19724         wxPyEndAllowThreads(__tstate);
19725         if (PyErr_Occurred()) SWIG_fail;
19726     }
19727     Py_INCREF(Py_None); resultobj = Py_None;
19728     return resultobj;
19729     fail:
19730     return NULL;
19731 }
19732
19733
19734 static PyObject *_wrap_PyScrolledWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19735     PyObject *resultobj;
19736     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19737     int arg2 ;
19738     int arg3 ;
19739     int arg4 ;
19740     int arg5 ;
19741     int arg6 = (int) wxSIZE_AUTO ;
19742     PyObject * obj0 = 0 ;
19743     PyObject * obj1 = 0 ;
19744     PyObject * obj2 = 0 ;
19745     PyObject * obj3 = 0 ;
19746     PyObject * obj4 = 0 ;
19747     PyObject * obj5 = 0 ;
19748     char *kwnames[] = {
19749         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
19750     };
19751
19752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyScrolledWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19754     if (SWIG_arg_fail(1)) SWIG_fail;
19755     {
19756         arg2 = (int)(SWIG_As_int(obj1));
19757         if (SWIG_arg_fail(2)) SWIG_fail;
19758     }
19759     {
19760         arg3 = (int)(SWIG_As_int(obj2));
19761         if (SWIG_arg_fail(3)) SWIG_fail;
19762     }
19763     {
19764         arg4 = (int)(SWIG_As_int(obj3));
19765         if (SWIG_arg_fail(4)) SWIG_fail;
19766     }
19767     {
19768         arg5 = (int)(SWIG_As_int(obj4));
19769         if (SWIG_arg_fail(5)) SWIG_fail;
19770     }
19771     if (obj5) {
19772         {
19773             arg6 = (int)(SWIG_As_int(obj5));
19774             if (SWIG_arg_fail(6)) SWIG_fail;
19775         }
19776     }
19777     {
19778         PyThreadState* __tstate = wxPyBeginAllowThreads();
19779         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
19780
19781         wxPyEndAllowThreads(__tstate);
19782         if (PyErr_Occurred()) SWIG_fail;
19783     }
19784     Py_INCREF(Py_None); resultobj = Py_None;
19785     return resultobj;
19786     fail:
19787     return NULL;
19788 }
19789
19790
19791 static PyObject *_wrap_PyScrolledWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19792     PyObject *resultobj;
19793     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19794     int arg2 ;
19795     int arg3 ;
19796     PyObject * obj0 = 0 ;
19797     PyObject * obj1 = 0 ;
19798     PyObject * obj2 = 0 ;
19799     char *kwnames[] = {
19800         (char *) "self",(char *) "width",(char *) "height", NULL
19801     };
19802
19803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19804     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19805     if (SWIG_arg_fail(1)) SWIG_fail;
19806     {
19807         arg2 = (int)(SWIG_As_int(obj1));
19808         if (SWIG_arg_fail(2)) SWIG_fail;
19809     }
19810     {
19811         arg3 = (int)(SWIG_As_int(obj2));
19812         if (SWIG_arg_fail(3)) SWIG_fail;
19813     }
19814     {
19815         PyThreadState* __tstate = wxPyBeginAllowThreads();
19816         (arg1)->base_DoSetClientSize(arg2,arg3);
19817
19818         wxPyEndAllowThreads(__tstate);
19819         if (PyErr_Occurred()) SWIG_fail;
19820     }
19821     Py_INCREF(Py_None); resultobj = Py_None;
19822     return resultobj;
19823     fail:
19824     return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_PyScrolledWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19829     PyObject *resultobj;
19830     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19831     int arg2 ;
19832     int arg3 ;
19833     PyObject * obj0 = 0 ;
19834     PyObject * obj1 = 0 ;
19835     PyObject * obj2 = 0 ;
19836     char *kwnames[] = {
19837         (char *) "self",(char *) "x",(char *) "y", NULL
19838     };
19839
19840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19841     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19842     if (SWIG_arg_fail(1)) SWIG_fail;
19843     {
19844         arg2 = (int)(SWIG_As_int(obj1));
19845         if (SWIG_arg_fail(2)) SWIG_fail;
19846     }
19847     {
19848         arg3 = (int)(SWIG_As_int(obj2));
19849         if (SWIG_arg_fail(3)) SWIG_fail;
19850     }
19851     {
19852         PyThreadState* __tstate = wxPyBeginAllowThreads();
19853         (arg1)->base_DoSetVirtualSize(arg2,arg3);
19854
19855         wxPyEndAllowThreads(__tstate);
19856         if (PyErr_Occurred()) SWIG_fail;
19857     }
19858     Py_INCREF(Py_None); resultobj = Py_None;
19859     return resultobj;
19860     fail:
19861     return NULL;
19862 }
19863
19864
19865 static PyObject *_wrap_PyScrolledWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19866     PyObject *resultobj;
19867     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19868     int *arg2 = (int *) 0 ;
19869     int *arg3 = (int *) 0 ;
19870     int temp2 ;
19871     int res2 = 0 ;
19872     int temp3 ;
19873     int res3 = 0 ;
19874     PyObject * obj0 = 0 ;
19875     char *kwnames[] = {
19876         (char *) "self", NULL
19877     };
19878
19879     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19880     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
19882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19883     if (SWIG_arg_fail(1)) SWIG_fail;
19884     {
19885         PyThreadState* __tstate = wxPyBeginAllowThreads();
19886         ((wxPyScrolledWindow const *)arg1)->base_DoGetSize(arg2,arg3);
19887
19888         wxPyEndAllowThreads(__tstate);
19889         if (PyErr_Occurred()) SWIG_fail;
19890     }
19891     Py_INCREF(Py_None); resultobj = Py_None;
19892     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19893     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19894     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19895     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19896     return resultobj;
19897     fail:
19898     return NULL;
19899 }
19900
19901
19902 static PyObject *_wrap_PyScrolledWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19903     PyObject *resultobj;
19904     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19905     int *arg2 = (int *) 0 ;
19906     int *arg3 = (int *) 0 ;
19907     int temp2 ;
19908     int res2 = 0 ;
19909     int temp3 ;
19910     int res3 = 0 ;
19911     PyObject * obj0 = 0 ;
19912     char *kwnames[] = {
19913         (char *) "self", NULL
19914     };
19915
19916     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19917     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19920     if (SWIG_arg_fail(1)) SWIG_fail;
19921     {
19922         PyThreadState* __tstate = wxPyBeginAllowThreads();
19923         ((wxPyScrolledWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
19924
19925         wxPyEndAllowThreads(__tstate);
19926         if (PyErr_Occurred()) SWIG_fail;
19927     }
19928     Py_INCREF(Py_None); resultobj = Py_None;
19929     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19930     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19931     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19932     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19933     return resultobj;
19934     fail:
19935     return NULL;
19936 }
19937
19938
19939 static PyObject *_wrap_PyScrolledWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19940     PyObject *resultobj;
19941     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19942     int *arg2 = (int *) 0 ;
19943     int *arg3 = (int *) 0 ;
19944     int temp2 ;
19945     int res2 = 0 ;
19946     int temp3 ;
19947     int res3 = 0 ;
19948     PyObject * obj0 = 0 ;
19949     char *kwnames[] = {
19950         (char *) "self", NULL
19951     };
19952
19953     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19954     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
19956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19957     if (SWIG_arg_fail(1)) SWIG_fail;
19958     {
19959         PyThreadState* __tstate = wxPyBeginAllowThreads();
19960         ((wxPyScrolledWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
19961
19962         wxPyEndAllowThreads(__tstate);
19963         if (PyErr_Occurred()) SWIG_fail;
19964     }
19965     Py_INCREF(Py_None); resultobj = Py_None;
19966     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19967     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19968     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19969     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19970     return resultobj;
19971     fail:
19972     return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_PyScrolledWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19977     PyObject *resultobj;
19978     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19979     wxSize result;
19980     PyObject * obj0 = 0 ;
19981     char *kwnames[] = {
19982         (char *) "self", NULL
19983     };
19984
19985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19987     if (SWIG_arg_fail(1)) SWIG_fail;
19988     {
19989         PyThreadState* __tstate = wxPyBeginAllowThreads();
19990         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetVirtualSize();
19991
19992         wxPyEndAllowThreads(__tstate);
19993         if (PyErr_Occurred()) SWIG_fail;
19994     }
19995     {
19996         wxSize * resultptr;
19997         resultptr = new wxSize((wxSize &)(result));
19998         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19999     }
20000     return resultobj;
20001     fail:
20002     return NULL;
20003 }
20004
20005
20006 static PyObject *_wrap_PyScrolledWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
20007     PyObject *resultobj;
20008     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20009     wxSize result;
20010     PyObject * obj0 = 0 ;
20011     char *kwnames[] = {
20012         (char *) "self", NULL
20013     };
20014
20015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
20016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20017     if (SWIG_arg_fail(1)) SWIG_fail;
20018     {
20019         PyThreadState* __tstate = wxPyBeginAllowThreads();
20020         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetBestSize();
20021
20022         wxPyEndAllowThreads(__tstate);
20023         if (PyErr_Occurred()) SWIG_fail;
20024     }
20025     {
20026         wxSize * resultptr;
20027         resultptr = new wxSize((wxSize &)(result));
20028         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20029     }
20030     return resultobj;
20031     fail:
20032     return NULL;
20033 }
20034
20035
20036 static PyObject *_wrap_PyScrolledWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
20037     PyObject *resultobj;
20038     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20039     PyObject * obj0 = 0 ;
20040     char *kwnames[] = {
20041         (char *) "self", NULL
20042     };
20043
20044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_InitDialog",kwnames,&obj0)) goto fail;
20045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20046     if (SWIG_arg_fail(1)) SWIG_fail;
20047     {
20048         PyThreadState* __tstate = wxPyBeginAllowThreads();
20049         (arg1)->base_InitDialog();
20050
20051         wxPyEndAllowThreads(__tstate);
20052         if (PyErr_Occurred()) SWIG_fail;
20053     }
20054     Py_INCREF(Py_None); resultobj = Py_None;
20055     return resultobj;
20056     fail:
20057     return NULL;
20058 }
20059
20060
20061 static PyObject *_wrap_PyScrolledWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20062     PyObject *resultobj;
20063     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20064     bool result;
20065     PyObject * obj0 = 0 ;
20066     char *kwnames[] = {
20067         (char *) "self", NULL
20068     };
20069
20070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
20071     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20072     if (SWIG_arg_fail(1)) SWIG_fail;
20073     {
20074         PyThreadState* __tstate = wxPyBeginAllowThreads();
20075         result = (bool)(arg1)->base_TransferDataToWindow();
20076
20077         wxPyEndAllowThreads(__tstate);
20078         if (PyErr_Occurred()) SWIG_fail;
20079     }
20080     {
20081         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082     }
20083     return resultobj;
20084     fail:
20085     return NULL;
20086 }
20087
20088
20089 static PyObject *_wrap_PyScrolledWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20090     PyObject *resultobj;
20091     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20092     bool result;
20093     PyObject * obj0 = 0 ;
20094     char *kwnames[] = {
20095         (char *) "self", NULL
20096     };
20097
20098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
20099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20100     if (SWIG_arg_fail(1)) SWIG_fail;
20101     {
20102         PyThreadState* __tstate = wxPyBeginAllowThreads();
20103         result = (bool)(arg1)->base_TransferDataFromWindow();
20104
20105         wxPyEndAllowThreads(__tstate);
20106         if (PyErr_Occurred()) SWIG_fail;
20107     }
20108     {
20109         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110     }
20111     return resultobj;
20112     fail:
20113     return NULL;
20114 }
20115
20116
20117 static PyObject *_wrap_PyScrolledWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
20118     PyObject *resultobj;
20119     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20120     bool result;
20121     PyObject * obj0 = 0 ;
20122     char *kwnames[] = {
20123         (char *) "self", NULL
20124     };
20125
20126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_Validate",kwnames,&obj0)) goto fail;
20127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20128     if (SWIG_arg_fail(1)) SWIG_fail;
20129     {
20130         PyThreadState* __tstate = wxPyBeginAllowThreads();
20131         result = (bool)(arg1)->base_Validate();
20132
20133         wxPyEndAllowThreads(__tstate);
20134         if (PyErr_Occurred()) SWIG_fail;
20135     }
20136     {
20137         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20138     }
20139     return resultobj;
20140     fail:
20141     return NULL;
20142 }
20143
20144
20145 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
20146     PyObject *resultobj;
20147     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20148     bool result;
20149     PyObject * obj0 = 0 ;
20150     char *kwnames[] = {
20151         (char *) "self", NULL
20152     };
20153
20154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
20155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20156     if (SWIG_arg_fail(1)) SWIG_fail;
20157     {
20158         PyThreadState* __tstate = wxPyBeginAllowThreads();
20159         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocus();
20160
20161         wxPyEndAllowThreads(__tstate);
20162         if (PyErr_Occurred()) SWIG_fail;
20163     }
20164     {
20165         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20166     }
20167     return resultobj;
20168     fail:
20169     return NULL;
20170 }
20171
20172
20173 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
20174     PyObject *resultobj;
20175     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20176     bool result;
20177     PyObject * obj0 = 0 ;
20178     char *kwnames[] = {
20179         (char *) "self", NULL
20180     };
20181
20182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
20183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20184     if (SWIG_arg_fail(1)) SWIG_fail;
20185     {
20186         PyThreadState* __tstate = wxPyBeginAllowThreads();
20187         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
20188
20189         wxPyEndAllowThreads(__tstate);
20190         if (PyErr_Occurred()) SWIG_fail;
20191     }
20192     {
20193         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20194     }
20195     return resultobj;
20196     fail:
20197     return NULL;
20198 }
20199
20200
20201 static PyObject *_wrap_PyScrolledWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
20202     PyObject *resultobj;
20203     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20204     wxSize result;
20205     PyObject * obj0 = 0 ;
20206     char *kwnames[] = {
20207         (char *) "self", NULL
20208     };
20209
20210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
20211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20212     if (SWIG_arg_fail(1)) SWIG_fail;
20213     {
20214         PyThreadState* __tstate = wxPyBeginAllowThreads();
20215         result = ((wxPyScrolledWindow const *)arg1)->base_GetMaxSize();
20216
20217         wxPyEndAllowThreads(__tstate);
20218         if (PyErr_Occurred()) SWIG_fail;
20219     }
20220     {
20221         wxSize * resultptr;
20222         resultptr = new wxSize((wxSize &)(result));
20223         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20224     }
20225     return resultobj;
20226     fail:
20227     return NULL;
20228 }
20229
20230
20231 static PyObject *_wrap_PyScrolledWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
20232     PyObject *resultobj;
20233     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20234     wxWindow *arg2 = (wxWindow *) 0 ;
20235     PyObject * obj0 = 0 ;
20236     PyObject * obj1 = 0 ;
20237     char *kwnames[] = {
20238         (char *) "self",(char *) "child", NULL
20239     };
20240
20241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
20242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20243     if (SWIG_arg_fail(1)) SWIG_fail;
20244     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20245     if (SWIG_arg_fail(2)) SWIG_fail;
20246     {
20247         PyThreadState* __tstate = wxPyBeginAllowThreads();
20248         (arg1)->base_AddChild(arg2);
20249
20250         wxPyEndAllowThreads(__tstate);
20251         if (PyErr_Occurred()) SWIG_fail;
20252     }
20253     Py_INCREF(Py_None); resultobj = Py_None;
20254     return resultobj;
20255     fail:
20256     return NULL;
20257 }
20258
20259
20260 static PyObject *_wrap_PyScrolledWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
20261     PyObject *resultobj;
20262     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20263     wxWindow *arg2 = (wxWindow *) 0 ;
20264     PyObject * obj0 = 0 ;
20265     PyObject * obj1 = 0 ;
20266     char *kwnames[] = {
20267         (char *) "self",(char *) "child", NULL
20268     };
20269
20270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
20271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20272     if (SWIG_arg_fail(1)) SWIG_fail;
20273     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20274     if (SWIG_arg_fail(2)) SWIG_fail;
20275     {
20276         PyThreadState* __tstate = wxPyBeginAllowThreads();
20277         (arg1)->base_RemoveChild(arg2);
20278
20279         wxPyEndAllowThreads(__tstate);
20280         if (PyErr_Occurred()) SWIG_fail;
20281     }
20282     Py_INCREF(Py_None); resultobj = Py_None;
20283     return resultobj;
20284     fail:
20285     return NULL;
20286 }
20287
20288
20289 static PyObject *_wrap_PyScrolledWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
20290     PyObject *resultobj;
20291     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20292     bool result;
20293     PyObject * obj0 = 0 ;
20294     char *kwnames[] = {
20295         (char *) "self", NULL
20296     };
20297
20298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
20299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20300     if (SWIG_arg_fail(1)) SWIG_fail;
20301     {
20302         PyThreadState* __tstate = wxPyBeginAllowThreads();
20303         result = (bool)((wxPyScrolledWindow const *)arg1)->base_ShouldInheritColours();
20304
20305         wxPyEndAllowThreads(__tstate);
20306         if (PyErr_Occurred()) SWIG_fail;
20307     }
20308     {
20309         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20310     }
20311     return resultobj;
20312     fail:
20313     return NULL;
20314 }
20315
20316
20317 static PyObject *_wrap_PyScrolledWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
20318     PyObject *resultobj;
20319     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20320     wxColour *arg2 = 0 ;
20321     wxColour temp2 ;
20322     PyObject * obj0 = 0 ;
20323     PyObject * obj1 = 0 ;
20324     char *kwnames[] = {
20325         (char *) "self",(char *) "c", NULL
20326     };
20327
20328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
20329     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20330     if (SWIG_arg_fail(1)) SWIG_fail;
20331     {
20332         arg2 = &temp2;
20333         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20334     }
20335     {
20336         PyThreadState* __tstate = wxPyBeginAllowThreads();
20337         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
20338
20339         wxPyEndAllowThreads(__tstate);
20340         if (PyErr_Occurred()) SWIG_fail;
20341     }
20342     Py_INCREF(Py_None); resultobj = Py_None;
20343     return resultobj;
20344     fail:
20345     return NULL;
20346 }
20347
20348
20349 static PyObject *_wrap_PyScrolledWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
20350     PyObject *resultobj;
20351     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20352     wxVisualAttributes result;
20353     PyObject * obj0 = 0 ;
20354     char *kwnames[] = {
20355         (char *) "self", NULL
20356     };
20357
20358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
20359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20360     if (SWIG_arg_fail(1)) SWIG_fail;
20361     {
20362         PyThreadState* __tstate = wxPyBeginAllowThreads();
20363         result = (arg1)->base_GetDefaultAttributes();
20364
20365         wxPyEndAllowThreads(__tstate);
20366         if (PyErr_Occurred()) SWIG_fail;
20367     }
20368     {
20369         wxVisualAttributes * resultptr;
20370         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
20371         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
20372     }
20373     return resultobj;
20374     fail:
20375     return NULL;
20376 }
20377
20378
20379 static PyObject * PyScrolledWindow_swigregister(PyObject *, PyObject *args) {
20380     PyObject *obj;
20381     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20382     SWIG_TypeClientData(SWIGTYPE_p_wxPyScrolledWindow, obj);
20383     Py_INCREF(obj);
20384     return Py_BuildValue((char *)"");
20385 }
20386 static int _wrap_PrintoutTitleStr_set(PyObject *) {
20387     PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
20388     return 1;
20389 }
20390
20391
20392 static PyObject *_wrap_PrintoutTitleStr_get(void) {
20393     PyObject *pyobj;
20394
20395     {
20396 #if wxUSE_UNICODE
20397         pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20398 #else
20399         pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20400 #endif
20401     }
20402     return pyobj;
20403 }
20404
20405
20406 static int _wrap_PreviewCanvasNameStr_set(PyObject *) {
20407     PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
20408     return 1;
20409 }
20410
20411
20412 static PyObject *_wrap_PreviewCanvasNameStr_get(void) {
20413     PyObject *pyobj;
20414
20415     {
20416 #if wxUSE_UNICODE
20417         pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20418 #else
20419         pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20420 #endif
20421     }
20422     return pyobj;
20423 }
20424
20425
20426 static PyObject *_wrap_new_PrintData__SWIG_0(PyObject *, PyObject *args) {
20427     PyObject *resultobj;
20428     wxPrintData *result;
20429
20430     if(!PyArg_ParseTuple(args,(char *)":new_PrintData")) goto fail;
20431     {
20432         PyThreadState* __tstate = wxPyBeginAllowThreads();
20433         result = (wxPrintData *)new wxPrintData();
20434
20435         wxPyEndAllowThreads(__tstate);
20436         if (PyErr_Occurred()) SWIG_fail;
20437     }
20438     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20439     return resultobj;
20440     fail:
20441     return NULL;
20442 }
20443
20444
20445 static PyObject *_wrap_new_PrintData__SWIG_1(PyObject *, PyObject *args) {
20446     PyObject *resultobj;
20447     wxPrintData *arg1 = 0 ;
20448     wxPrintData *result;
20449     PyObject * obj0 = 0 ;
20450
20451     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintData",&obj0)) goto fail;
20452     {
20453         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20454         if (SWIG_arg_fail(1)) SWIG_fail;
20455         if (arg1 == NULL) {
20456             SWIG_null_ref("wxPrintData");
20457         }
20458         if (SWIG_arg_fail(1)) SWIG_fail;
20459     }
20460     {
20461         PyThreadState* __tstate = wxPyBeginAllowThreads();
20462         result = (wxPrintData *)new wxPrintData((wxPrintData const &)*arg1);
20463
20464         wxPyEndAllowThreads(__tstate);
20465         if (PyErr_Occurred()) SWIG_fail;
20466     }
20467     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20468     return resultobj;
20469     fail:
20470     return NULL;
20471 }
20472
20473
20474 static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args) {
20475     int argc;
20476     PyObject *argv[2];
20477     int ii;
20478
20479     argc = PyObject_Length(args);
20480     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
20481         argv[ii] = PyTuple_GetItem(args,ii);
20482     }
20483     if (argc == 0) {
20484         return _wrap_new_PrintData__SWIG_0(self,args);
20485     }
20486     if (argc == 1) {
20487         int _v;
20488         {
20489             void *ptr = 0;
20490             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
20491                 _v = 0;
20492                 PyErr_Clear();
20493             } else {
20494                 _v = (ptr != 0);
20495             }
20496         }
20497         if (_v) {
20498             return _wrap_new_PrintData__SWIG_1(self,args);
20499         }
20500     }
20501
20502     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintData'");
20503     return NULL;
20504 }
20505
20506
20507 static PyObject *_wrap_delete_PrintData(PyObject *, PyObject *args, PyObject *kwargs) {
20508     PyObject *resultobj;
20509     wxPrintData *arg1 = (wxPrintData *) 0 ;
20510     PyObject * obj0 = 0 ;
20511     char *kwnames[] = {
20512         (char *) "self", NULL
20513     };
20514
20515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintData",kwnames,&obj0)) goto fail;
20516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20517     if (SWIG_arg_fail(1)) SWIG_fail;
20518     {
20519         PyThreadState* __tstate = wxPyBeginAllowThreads();
20520         delete arg1;
20521
20522         wxPyEndAllowThreads(__tstate);
20523         if (PyErr_Occurred()) SWIG_fail;
20524     }
20525     Py_INCREF(Py_None); resultobj = Py_None;
20526     return resultobj;
20527     fail:
20528     return NULL;
20529 }
20530
20531
20532 static PyObject *_wrap_PrintData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20533     PyObject *resultobj;
20534     wxPrintData *arg1 = (wxPrintData *) 0 ;
20535     int result;
20536     PyObject * obj0 = 0 ;
20537     char *kwnames[] = {
20538         (char *) "self", NULL
20539     };
20540
20541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetNoCopies",kwnames,&obj0)) goto fail;
20542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20543     if (SWIG_arg_fail(1)) SWIG_fail;
20544     {
20545         PyThreadState* __tstate = wxPyBeginAllowThreads();
20546         result = (int)(arg1)->GetNoCopies();
20547
20548         wxPyEndAllowThreads(__tstate);
20549         if (PyErr_Occurred()) SWIG_fail;
20550     }
20551     {
20552         resultobj = SWIG_From_int((int)(result));
20553     }
20554     return resultobj;
20555     fail:
20556     return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_PrintData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20561     PyObject *resultobj;
20562     wxPrintData *arg1 = (wxPrintData *) 0 ;
20563     bool result;
20564     PyObject * obj0 = 0 ;
20565     char *kwnames[] = {
20566         (char *) "self", NULL
20567     };
20568
20569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetCollate",kwnames,&obj0)) goto fail;
20570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20571     if (SWIG_arg_fail(1)) SWIG_fail;
20572     {
20573         PyThreadState* __tstate = wxPyBeginAllowThreads();
20574         result = (bool)(arg1)->GetCollate();
20575
20576         wxPyEndAllowThreads(__tstate);
20577         if (PyErr_Occurred()) SWIG_fail;
20578     }
20579     {
20580         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581     }
20582     return resultobj;
20583     fail:
20584     return NULL;
20585 }
20586
20587
20588 static PyObject *_wrap_PrintData_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20589     PyObject *resultobj;
20590     wxPrintData *arg1 = (wxPrintData *) 0 ;
20591     int result;
20592     PyObject * obj0 = 0 ;
20593     char *kwnames[] = {
20594         (char *) "self", NULL
20595     };
20596
20597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetOrientation",kwnames,&obj0)) goto fail;
20598     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20599     if (SWIG_arg_fail(1)) SWIG_fail;
20600     {
20601         PyThreadState* __tstate = wxPyBeginAllowThreads();
20602         result = (int)(arg1)->GetOrientation();
20603
20604         wxPyEndAllowThreads(__tstate);
20605         if (PyErr_Occurred()) SWIG_fail;
20606     }
20607     {
20608         resultobj = SWIG_From_int((int)(result));
20609     }
20610     return resultobj;
20611     fail:
20612     return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_PrintData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
20617     PyObject *resultobj;
20618     wxPrintData *arg1 = (wxPrintData *) 0 ;
20619     bool result;
20620     PyObject * obj0 = 0 ;
20621     char *kwnames[] = {
20622         (char *) "self", NULL
20623     };
20624
20625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_Ok",kwnames,&obj0)) goto fail;
20626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20627     if (SWIG_arg_fail(1)) SWIG_fail;
20628     {
20629         PyThreadState* __tstate = wxPyBeginAllowThreads();
20630         result = (bool)(arg1)->Ok();
20631
20632         wxPyEndAllowThreads(__tstate);
20633         if (PyErr_Occurred()) SWIG_fail;
20634     }
20635     {
20636         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637     }
20638     return resultobj;
20639     fail:
20640     return NULL;
20641 }
20642
20643
20644 static PyObject *_wrap_PrintData_GetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20645     PyObject *resultobj;
20646     wxPrintData *arg1 = (wxPrintData *) 0 ;
20647     wxString *result;
20648     PyObject * obj0 = 0 ;
20649     char *kwnames[] = {
20650         (char *) "self", NULL
20651     };
20652
20653     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterName",kwnames,&obj0)) goto fail;
20654     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20655     if (SWIG_arg_fail(1)) SWIG_fail;
20656     {
20657         PyThreadState* __tstate = wxPyBeginAllowThreads();
20658         {
20659             wxString const &_result_ref = (arg1)->GetPrinterName();
20660             result = (wxString *) &_result_ref;
20661         }
20662
20663         wxPyEndAllowThreads(__tstate);
20664         if (PyErr_Occurred()) SWIG_fail;
20665     }
20666     {
20667 #if wxUSE_UNICODE
20668         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20669 #else
20670         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20671 #endif
20672     }
20673     return resultobj;
20674     fail:
20675     return NULL;
20676 }
20677
20678
20679 static PyObject *_wrap_PrintData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20680     PyObject *resultobj;
20681     wxPrintData *arg1 = (wxPrintData *) 0 ;
20682     bool result;
20683     PyObject * obj0 = 0 ;
20684     char *kwnames[] = {
20685         (char *) "self", NULL
20686     };
20687
20688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetColour",kwnames,&obj0)) goto fail;
20689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20690     if (SWIG_arg_fail(1)) SWIG_fail;
20691     {
20692         PyThreadState* __tstate = wxPyBeginAllowThreads();
20693         result = (bool)(arg1)->GetColour();
20694
20695         wxPyEndAllowThreads(__tstate);
20696         if (PyErr_Occurred()) SWIG_fail;
20697     }
20698     {
20699         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20700     }
20701     return resultobj;
20702     fail:
20703     return NULL;
20704 }
20705
20706
20707 static PyObject *_wrap_PrintData_GetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20708     PyObject *resultobj;
20709     wxPrintData *arg1 = (wxPrintData *) 0 ;
20710     wxDuplexMode result;
20711     PyObject * obj0 = 0 ;
20712     char *kwnames[] = {
20713         (char *) "self", NULL
20714     };
20715
20716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetDuplex",kwnames,&obj0)) goto fail;
20717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20718     if (SWIG_arg_fail(1)) SWIG_fail;
20719     {
20720         PyThreadState* __tstate = wxPyBeginAllowThreads();
20721         result = (wxDuplexMode)(arg1)->GetDuplex();
20722
20723         wxPyEndAllowThreads(__tstate);
20724         if (PyErr_Occurred()) SWIG_fail;
20725     }
20726     resultobj = SWIG_From_int((result));
20727     return resultobj;
20728     fail:
20729     return NULL;
20730 }
20731
20732
20733 static PyObject *_wrap_PrintData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20734     PyObject *resultobj;
20735     wxPrintData *arg1 = (wxPrintData *) 0 ;
20736     wxPaperSize result;
20737     PyObject * obj0 = 0 ;
20738     char *kwnames[] = {
20739         (char *) "self", NULL
20740     };
20741
20742     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperId",kwnames,&obj0)) goto fail;
20743     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20744     if (SWIG_arg_fail(1)) SWIG_fail;
20745     {
20746         PyThreadState* __tstate = wxPyBeginAllowThreads();
20747         result = (wxPaperSize)(arg1)->GetPaperId();
20748
20749         wxPyEndAllowThreads(__tstate);
20750         if (PyErr_Occurred()) SWIG_fail;
20751     }
20752     resultobj = SWIG_From_int((result));
20753     return resultobj;
20754     fail:
20755     return NULL;
20756 }
20757
20758
20759 static PyObject *_wrap_PrintData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20760     PyObject *resultobj;
20761     wxPrintData *arg1 = (wxPrintData *) 0 ;
20762     wxSize *result;
20763     PyObject * obj0 = 0 ;
20764     char *kwnames[] = {
20765         (char *) "self", NULL
20766     };
20767
20768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperSize",kwnames,&obj0)) goto fail;
20769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20770     if (SWIG_arg_fail(1)) SWIG_fail;
20771     {
20772         PyThreadState* __tstate = wxPyBeginAllowThreads();
20773         {
20774             wxSize const &_result_ref = (arg1)->GetPaperSize();
20775             result = (wxSize *) &_result_ref;
20776         }
20777
20778         wxPyEndAllowThreads(__tstate);
20779         if (PyErr_Occurred()) SWIG_fail;
20780     }
20781     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20782     return resultobj;
20783     fail:
20784     return NULL;
20785 }
20786
20787
20788 static PyObject *_wrap_PrintData_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20789     PyObject *resultobj;
20790     wxPrintData *arg1 = (wxPrintData *) 0 ;
20791     int result;
20792     PyObject * obj0 = 0 ;
20793     char *kwnames[] = {
20794         (char *) "self", NULL
20795     };
20796
20797     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetQuality",kwnames,&obj0)) goto fail;
20798     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20799     if (SWIG_arg_fail(1)) SWIG_fail;
20800     {
20801         PyThreadState* __tstate = wxPyBeginAllowThreads();
20802         result = (int)(arg1)->GetQuality();
20803
20804         wxPyEndAllowThreads(__tstate);
20805         if (PyErr_Occurred()) SWIG_fail;
20806     }
20807     {
20808         resultobj = SWIG_From_int((int)(result));
20809     }
20810     return resultobj;
20811     fail:
20812     return NULL;
20813 }
20814
20815
20816 static PyObject *_wrap_PrintData_GetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20817     PyObject *resultobj;
20818     wxPrintData *arg1 = (wxPrintData *) 0 ;
20819     wxPrintBin result;
20820     PyObject * obj0 = 0 ;
20821     char *kwnames[] = {
20822         (char *) "self", NULL
20823     };
20824
20825     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetBin",kwnames,&obj0)) goto fail;
20826     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20827     if (SWIG_arg_fail(1)) SWIG_fail;
20828     {
20829         PyThreadState* __tstate = wxPyBeginAllowThreads();
20830         result = (wxPrintBin)(arg1)->GetBin();
20831
20832         wxPyEndAllowThreads(__tstate);
20833         if (PyErr_Occurred()) SWIG_fail;
20834     }
20835     resultobj = SWIG_From_int((result));
20836     return resultobj;
20837     fail:
20838     return NULL;
20839 }
20840
20841
20842 static PyObject *_wrap_PrintData_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
20843     PyObject *resultobj;
20844     wxPrintData *arg1 = (wxPrintData *) 0 ;
20845     wxPrintMode result;
20846     PyObject * obj0 = 0 ;
20847     char *kwnames[] = {
20848         (char *) "self", NULL
20849     };
20850
20851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrintMode",kwnames,&obj0)) goto fail;
20852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20853     if (SWIG_arg_fail(1)) SWIG_fail;
20854     {
20855         PyThreadState* __tstate = wxPyBeginAllowThreads();
20856         result = (wxPrintMode)((wxPrintData const *)arg1)->GetPrintMode();
20857
20858         wxPyEndAllowThreads(__tstate);
20859         if (PyErr_Occurred()) SWIG_fail;
20860     }
20861     resultobj = SWIG_From_int((result));
20862     return resultobj;
20863     fail:
20864     return NULL;
20865 }
20866
20867
20868 static PyObject *_wrap_PrintData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20869     PyObject *resultobj;
20870     wxPrintData *arg1 = (wxPrintData *) 0 ;
20871     int arg2 ;
20872     PyObject * obj0 = 0 ;
20873     PyObject * obj1 = 0 ;
20874     char *kwnames[] = {
20875         (char *) "self",(char *) "v", NULL
20876     };
20877
20878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
20879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20880     if (SWIG_arg_fail(1)) SWIG_fail;
20881     {
20882         arg2 = (int)(SWIG_As_int(obj1));
20883         if (SWIG_arg_fail(2)) SWIG_fail;
20884     }
20885     {
20886         PyThreadState* __tstate = wxPyBeginAllowThreads();
20887         (arg1)->SetNoCopies(arg2);
20888
20889         wxPyEndAllowThreads(__tstate);
20890         if (PyErr_Occurred()) SWIG_fail;
20891     }
20892     Py_INCREF(Py_None); resultobj = Py_None;
20893     return resultobj;
20894     fail:
20895     return NULL;
20896 }
20897
20898
20899 static PyObject *_wrap_PrintData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20900     PyObject *resultobj;
20901     wxPrintData *arg1 = (wxPrintData *) 0 ;
20902     bool arg2 ;
20903     PyObject * obj0 = 0 ;
20904     PyObject * obj1 = 0 ;
20905     char *kwnames[] = {
20906         (char *) "self",(char *) "flag", NULL
20907     };
20908
20909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
20910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20911     if (SWIG_arg_fail(1)) SWIG_fail;
20912     {
20913         arg2 = (bool)(SWIG_As_bool(obj1));
20914         if (SWIG_arg_fail(2)) SWIG_fail;
20915     }
20916     {
20917         PyThreadState* __tstate = wxPyBeginAllowThreads();
20918         (arg1)->SetCollate(arg2);
20919
20920         wxPyEndAllowThreads(__tstate);
20921         if (PyErr_Occurred()) SWIG_fail;
20922     }
20923     Py_INCREF(Py_None); resultobj = Py_None;
20924     return resultobj;
20925     fail:
20926     return NULL;
20927 }
20928
20929
20930 static PyObject *_wrap_PrintData_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20931     PyObject *resultobj;
20932     wxPrintData *arg1 = (wxPrintData *) 0 ;
20933     int arg2 ;
20934     PyObject * obj0 = 0 ;
20935     PyObject * obj1 = 0 ;
20936     char *kwnames[] = {
20937         (char *) "self",(char *) "orient", NULL
20938     };
20939
20940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
20941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20942     if (SWIG_arg_fail(1)) SWIG_fail;
20943     {
20944         arg2 = (int)(SWIG_As_int(obj1));
20945         if (SWIG_arg_fail(2)) SWIG_fail;
20946     }
20947     {
20948         PyThreadState* __tstate = wxPyBeginAllowThreads();
20949         (arg1)->SetOrientation(arg2);
20950
20951         wxPyEndAllowThreads(__tstate);
20952         if (PyErr_Occurred()) SWIG_fail;
20953     }
20954     Py_INCREF(Py_None); resultobj = Py_None;
20955     return resultobj;
20956     fail:
20957     return NULL;
20958 }
20959
20960
20961 static PyObject *_wrap_PrintData_SetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20962     PyObject *resultobj;
20963     wxPrintData *arg1 = (wxPrintData *) 0 ;
20964     wxString *arg2 = 0 ;
20965     bool temp2 = false ;
20966     PyObject * obj0 = 0 ;
20967     PyObject * obj1 = 0 ;
20968     char *kwnames[] = {
20969         (char *) "self",(char *) "name", NULL
20970     };
20971
20972     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterName",kwnames,&obj0,&obj1)) goto fail;
20973     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20974     if (SWIG_arg_fail(1)) SWIG_fail;
20975     {
20976         arg2 = wxString_in_helper(obj1);
20977         if (arg2 == NULL) SWIG_fail;
20978         temp2 = true;
20979     }
20980     {
20981         PyThreadState* __tstate = wxPyBeginAllowThreads();
20982         (arg1)->SetPrinterName((wxString const &)*arg2);
20983
20984         wxPyEndAllowThreads(__tstate);
20985         if (PyErr_Occurred()) SWIG_fail;
20986     }
20987     Py_INCREF(Py_None); resultobj = Py_None;
20988     {
20989         if (temp2)
20990         delete arg2;
20991     }
20992     return resultobj;
20993     fail:
20994     {
20995         if (temp2)
20996         delete arg2;
20997     }
20998     return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_PrintData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
21003     PyObject *resultobj;
21004     wxPrintData *arg1 = (wxPrintData *) 0 ;
21005     bool arg2 ;
21006     PyObject * obj0 = 0 ;
21007     PyObject * obj1 = 0 ;
21008     char *kwnames[] = {
21009         (char *) "self",(char *) "colour", NULL
21010     };
21011
21012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetColour",kwnames,&obj0,&obj1)) goto fail;
21013     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21014     if (SWIG_arg_fail(1)) SWIG_fail;
21015     {
21016         arg2 = (bool)(SWIG_As_bool(obj1));
21017         if (SWIG_arg_fail(2)) SWIG_fail;
21018     }
21019     {
21020         PyThreadState* __tstate = wxPyBeginAllowThreads();
21021         (arg1)->SetColour(arg2);
21022
21023         wxPyEndAllowThreads(__tstate);
21024         if (PyErr_Occurred()) SWIG_fail;
21025     }
21026     Py_INCREF(Py_None); resultobj = Py_None;
21027     return resultobj;
21028     fail:
21029     return NULL;
21030 }
21031
21032
21033 static PyObject *_wrap_PrintData_SetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
21034     PyObject *resultobj;
21035     wxPrintData *arg1 = (wxPrintData *) 0 ;
21036     wxDuplexMode arg2 ;
21037     PyObject * obj0 = 0 ;
21038     PyObject * obj1 = 0 ;
21039     char *kwnames[] = {
21040         (char *) "self",(char *) "duplex", NULL
21041     };
21042
21043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetDuplex",kwnames,&obj0,&obj1)) goto fail;
21044     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21045     if (SWIG_arg_fail(1)) SWIG_fail;
21046     {
21047         arg2 = (wxDuplexMode)(SWIG_As_int(obj1));
21048         if (SWIG_arg_fail(2)) SWIG_fail;
21049     }
21050     {
21051         PyThreadState* __tstate = wxPyBeginAllowThreads();
21052         (arg1)->SetDuplex((wxDuplexMode )arg2);
21053
21054         wxPyEndAllowThreads(__tstate);
21055         if (PyErr_Occurred()) SWIG_fail;
21056     }
21057     Py_INCREF(Py_None); resultobj = Py_None;
21058     return resultobj;
21059     fail:
21060     return NULL;
21061 }
21062
21063
21064 static PyObject *_wrap_PrintData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
21065     PyObject *resultobj;
21066     wxPrintData *arg1 = (wxPrintData *) 0 ;
21067     wxPaperSize arg2 ;
21068     PyObject * obj0 = 0 ;
21069     PyObject * obj1 = 0 ;
21070     char *kwnames[] = {
21071         (char *) "self",(char *) "sizeId", NULL
21072     };
21073
21074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
21075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21076     if (SWIG_arg_fail(1)) SWIG_fail;
21077     {
21078         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
21079         if (SWIG_arg_fail(2)) SWIG_fail;
21080     }
21081     {
21082         PyThreadState* __tstate = wxPyBeginAllowThreads();
21083         (arg1)->SetPaperId((wxPaperSize )arg2);
21084
21085         wxPyEndAllowThreads(__tstate);
21086         if (PyErr_Occurred()) SWIG_fail;
21087     }
21088     Py_INCREF(Py_None); resultobj = Py_None;
21089     return resultobj;
21090     fail:
21091     return NULL;
21092 }
21093
21094
21095 static PyObject *_wrap_PrintData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
21096     PyObject *resultobj;
21097     wxPrintData *arg1 = (wxPrintData *) 0 ;
21098     wxSize *arg2 = 0 ;
21099     wxSize temp2 ;
21100     PyObject * obj0 = 0 ;
21101     PyObject * obj1 = 0 ;
21102     char *kwnames[] = {
21103         (char *) "self",(char *) "sz", NULL
21104     };
21105
21106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
21107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21108     if (SWIG_arg_fail(1)) SWIG_fail;
21109     {
21110         arg2 = &temp2;
21111         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
21112     }
21113     {
21114         PyThreadState* __tstate = wxPyBeginAllowThreads();
21115         (arg1)->SetPaperSize((wxSize const &)*arg2);
21116
21117         wxPyEndAllowThreads(__tstate);
21118         if (PyErr_Occurred()) SWIG_fail;
21119     }
21120     Py_INCREF(Py_None); resultobj = Py_None;
21121     return resultobj;
21122     fail:
21123     return NULL;
21124 }
21125
21126
21127 static PyObject *_wrap_PrintData_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
21128     PyObject *resultobj;
21129     wxPrintData *arg1 = (wxPrintData *) 0 ;
21130     int arg2 ;
21131     PyObject * obj0 = 0 ;
21132     PyObject * obj1 = 0 ;
21133     char *kwnames[] = {
21134         (char *) "self",(char *) "quality", NULL
21135     };
21136
21137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
21138     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21139     if (SWIG_arg_fail(1)) SWIG_fail;
21140     {
21141         arg2 = (int)(SWIG_As_int(obj1));
21142         if (SWIG_arg_fail(2)) SWIG_fail;
21143     }
21144     {
21145         PyThreadState* __tstate = wxPyBeginAllowThreads();
21146         (arg1)->SetQuality(arg2);
21147
21148         wxPyEndAllowThreads(__tstate);
21149         if (PyErr_Occurred()) SWIG_fail;
21150     }
21151     Py_INCREF(Py_None); resultobj = Py_None;
21152     return resultobj;
21153     fail:
21154     return NULL;
21155 }
21156
21157
21158 static PyObject *_wrap_PrintData_SetBin(PyObject *, PyObject *args, PyObject *kwargs) {
21159     PyObject *resultobj;
21160     wxPrintData *arg1 = (wxPrintData *) 0 ;
21161     wxPrintBin arg2 ;
21162     PyObject * obj0 = 0 ;
21163     PyObject * obj1 = 0 ;
21164     char *kwnames[] = {
21165         (char *) "self",(char *) "bin", NULL
21166     };
21167
21168     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetBin",kwnames,&obj0,&obj1)) goto fail;
21169     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21170     if (SWIG_arg_fail(1)) SWIG_fail;
21171     {
21172         arg2 = (wxPrintBin)(SWIG_As_int(obj1));
21173         if (SWIG_arg_fail(2)) SWIG_fail;
21174     }
21175     {
21176         PyThreadState* __tstate = wxPyBeginAllowThreads();
21177         (arg1)->SetBin((wxPrintBin )arg2);
21178
21179         wxPyEndAllowThreads(__tstate);
21180         if (PyErr_Occurred()) SWIG_fail;
21181     }
21182     Py_INCREF(Py_None); resultobj = Py_None;
21183     return resultobj;
21184     fail:
21185     return NULL;
21186 }
21187
21188
21189 static PyObject *_wrap_PrintData_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
21190     PyObject *resultobj;
21191     wxPrintData *arg1 = (wxPrintData *) 0 ;
21192     wxPrintMode arg2 ;
21193     PyObject * obj0 = 0 ;
21194     PyObject * obj1 = 0 ;
21195     char *kwnames[] = {
21196         (char *) "self",(char *) "printMode", NULL
21197     };
21198
21199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
21200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21201     if (SWIG_arg_fail(1)) SWIG_fail;
21202     {
21203         arg2 = (wxPrintMode)(SWIG_As_int(obj1));
21204         if (SWIG_arg_fail(2)) SWIG_fail;
21205     }
21206     {
21207         PyThreadState* __tstate = wxPyBeginAllowThreads();
21208         (arg1)->SetPrintMode((wxPrintMode )arg2);
21209
21210         wxPyEndAllowThreads(__tstate);
21211         if (PyErr_Occurred()) SWIG_fail;
21212     }
21213     Py_INCREF(Py_None); resultobj = Py_None;
21214     return resultobj;
21215     fail:
21216     return NULL;
21217 }
21218
21219
21220 static PyObject *_wrap_PrintData_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21221     PyObject *resultobj;
21222     wxPrintData *arg1 = (wxPrintData *) 0 ;
21223     wxString result;
21224     PyObject * obj0 = 0 ;
21225     char *kwnames[] = {
21226         (char *) "self", NULL
21227     };
21228
21229     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFilename",kwnames,&obj0)) goto fail;
21230     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21231     if (SWIG_arg_fail(1)) SWIG_fail;
21232     {
21233         PyThreadState* __tstate = wxPyBeginAllowThreads();
21234         result = ((wxPrintData const *)arg1)->GetFilename();
21235
21236         wxPyEndAllowThreads(__tstate);
21237         if (PyErr_Occurred()) SWIG_fail;
21238     }
21239     {
21240 #if wxUSE_UNICODE
21241         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21242 #else
21243         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21244 #endif
21245     }
21246     return resultobj;
21247     fail:
21248     return NULL;
21249 }
21250
21251
21252 static PyObject *_wrap_PrintData_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21253     PyObject *resultobj;
21254     wxPrintData *arg1 = (wxPrintData *) 0 ;
21255     wxString *arg2 = 0 ;
21256     bool temp2 = false ;
21257     PyObject * obj0 = 0 ;
21258     PyObject * obj1 = 0 ;
21259     char *kwnames[] = {
21260         (char *) "self",(char *) "filename", NULL
21261     };
21262
21263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFilename",kwnames,&obj0,&obj1)) goto fail;
21264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21265     if (SWIG_arg_fail(1)) SWIG_fail;
21266     {
21267         arg2 = wxString_in_helper(obj1);
21268         if (arg2 == NULL) SWIG_fail;
21269         temp2 = true;
21270     }
21271     {
21272         PyThreadState* __tstate = wxPyBeginAllowThreads();
21273         (arg1)->SetFilename((wxString const &)*arg2);
21274
21275         wxPyEndAllowThreads(__tstate);
21276         if (PyErr_Occurred()) SWIG_fail;
21277     }
21278     Py_INCREF(Py_None); resultobj = Py_None;
21279     {
21280         if (temp2)
21281         delete arg2;
21282     }
21283     return resultobj;
21284     fail:
21285     {
21286         if (temp2)
21287         delete arg2;
21288     }
21289     return NULL;
21290 }
21291
21292
21293 static PyObject *_wrap_PrintData_GetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21294     PyObject *resultobj;
21295     wxPrintData *arg1 = (wxPrintData *) 0 ;
21296     PyObject *result;
21297     PyObject * obj0 = 0 ;
21298     char *kwnames[] = {
21299         (char *) "self", NULL
21300     };
21301
21302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrivData",kwnames,&obj0)) goto fail;
21303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21304     if (SWIG_arg_fail(1)) SWIG_fail;
21305     {
21306         PyThreadState* __tstate = wxPyBeginAllowThreads();
21307         result = (PyObject *)wxPrintData_GetPrivData(arg1);
21308
21309         wxPyEndAllowThreads(__tstate);
21310         if (PyErr_Occurred()) SWIG_fail;
21311     }
21312     resultobj = result;
21313     return resultobj;
21314     fail:
21315     return NULL;
21316 }
21317
21318
21319 static PyObject *_wrap_PrintData_SetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21320     PyObject *resultobj;
21321     wxPrintData *arg1 = (wxPrintData *) 0 ;
21322     PyObject *arg2 = (PyObject *) 0 ;
21323     PyObject * obj0 = 0 ;
21324     PyObject * obj1 = 0 ;
21325     char *kwnames[] = {
21326         (char *) "self",(char *) "data", NULL
21327     };
21328
21329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrivData",kwnames,&obj0,&obj1)) goto fail;
21330     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21331     if (SWIG_arg_fail(1)) SWIG_fail;
21332     arg2 = obj1;
21333     {
21334         PyThreadState* __tstate = wxPyBeginAllowThreads();
21335         wxPrintData_SetPrivData(arg1,arg2);
21336
21337         wxPyEndAllowThreads(__tstate);
21338         if (PyErr_Occurred()) SWIG_fail;
21339     }
21340     Py_INCREF(Py_None); resultobj = Py_None;
21341     return resultobj;
21342     fail:
21343     return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_PrintData_GetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21348     PyObject *resultobj;
21349     wxPrintData *arg1 = (wxPrintData *) 0 ;
21350     wxString *result;
21351     PyObject * obj0 = 0 ;
21352     char *kwnames[] = {
21353         (char *) "self", NULL
21354     };
21355
21356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterCommand",kwnames,&obj0)) goto fail;
21357     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21358     if (SWIG_arg_fail(1)) SWIG_fail;
21359     {
21360         PyThreadState* __tstate = wxPyBeginAllowThreads();
21361         {
21362             wxString const &_result_ref = (arg1)->GetPrinterCommand();
21363             result = (wxString *) &_result_ref;
21364         }
21365
21366         wxPyEndAllowThreads(__tstate);
21367         if (PyErr_Occurred()) SWIG_fail;
21368     }
21369     {
21370 #if wxUSE_UNICODE
21371         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21372 #else
21373         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21374 #endif
21375     }
21376     return resultobj;
21377     fail:
21378     return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_PrintData_GetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21383     PyObject *resultobj;
21384     wxPrintData *arg1 = (wxPrintData *) 0 ;
21385     wxString *result;
21386     PyObject * obj0 = 0 ;
21387     char *kwnames[] = {
21388         (char *) "self", NULL
21389     };
21390
21391     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterOptions",kwnames,&obj0)) goto fail;
21392     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21393     if (SWIG_arg_fail(1)) SWIG_fail;
21394     {
21395         PyThreadState* __tstate = wxPyBeginAllowThreads();
21396         {
21397             wxString const &_result_ref = (arg1)->GetPrinterOptions();
21398             result = (wxString *) &_result_ref;
21399         }
21400
21401         wxPyEndAllowThreads(__tstate);
21402         if (PyErr_Occurred()) SWIG_fail;
21403     }
21404     {
21405 #if wxUSE_UNICODE
21406         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21407 #else
21408         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21409 #endif
21410     }
21411     return resultobj;
21412     fail:
21413     return NULL;
21414 }
21415
21416
21417 static PyObject *_wrap_PrintData_GetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21418     PyObject *resultobj;
21419     wxPrintData *arg1 = (wxPrintData *) 0 ;
21420     wxString *result;
21421     PyObject * obj0 = 0 ;
21422     char *kwnames[] = {
21423         (char *) "self", NULL
21424     };
21425
21426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPreviewCommand",kwnames,&obj0)) goto fail;
21427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21428     if (SWIG_arg_fail(1)) SWIG_fail;
21429     {
21430         PyThreadState* __tstate = wxPyBeginAllowThreads();
21431         {
21432             wxString const &_result_ref = (arg1)->GetPreviewCommand();
21433             result = (wxString *) &_result_ref;
21434         }
21435
21436         wxPyEndAllowThreads(__tstate);
21437         if (PyErr_Occurred()) SWIG_fail;
21438     }
21439     {
21440 #if wxUSE_UNICODE
21441         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21442 #else
21443         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21444 #endif
21445     }
21446     return resultobj;
21447     fail:
21448     return NULL;
21449 }
21450
21451
21452 static PyObject *_wrap_PrintData_GetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21453     PyObject *resultobj;
21454     wxPrintData *arg1 = (wxPrintData *) 0 ;
21455     wxString *result;
21456     PyObject * obj0 = 0 ;
21457     char *kwnames[] = {
21458         (char *) "self", NULL
21459     };
21460
21461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFontMetricPath",kwnames,&obj0)) goto fail;
21462     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21463     if (SWIG_arg_fail(1)) SWIG_fail;
21464     {
21465         PyThreadState* __tstate = wxPyBeginAllowThreads();
21466         {
21467             wxString const &_result_ref = (arg1)->GetFontMetricPath();
21468             result = (wxString *) &_result_ref;
21469         }
21470
21471         wxPyEndAllowThreads(__tstate);
21472         if (PyErr_Occurred()) SWIG_fail;
21473     }
21474     {
21475 #if wxUSE_UNICODE
21476         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21477 #else
21478         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21479 #endif
21480     }
21481     return resultobj;
21482     fail:
21483     return NULL;
21484 }
21485
21486
21487 static PyObject *_wrap_PrintData_GetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21488     PyObject *resultobj;
21489     wxPrintData *arg1 = (wxPrintData *) 0 ;
21490     double result;
21491     PyObject * obj0 = 0 ;
21492     char *kwnames[] = {
21493         (char *) "self", NULL
21494     };
21495
21496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleX",kwnames,&obj0)) goto fail;
21497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21498     if (SWIG_arg_fail(1)) SWIG_fail;
21499     {
21500         PyThreadState* __tstate = wxPyBeginAllowThreads();
21501         result = (double)(arg1)->GetPrinterScaleX();
21502
21503         wxPyEndAllowThreads(__tstate);
21504         if (PyErr_Occurred()) SWIG_fail;
21505     }
21506     {
21507         resultobj = SWIG_From_double((double)(result));
21508     }
21509     return resultobj;
21510     fail:
21511     return NULL;
21512 }
21513
21514
21515 static PyObject *_wrap_PrintData_GetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21516     PyObject *resultobj;
21517     wxPrintData *arg1 = (wxPrintData *) 0 ;
21518     double result;
21519     PyObject * obj0 = 0 ;
21520     char *kwnames[] = {
21521         (char *) "self", NULL
21522     };
21523
21524     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleY",kwnames,&obj0)) goto fail;
21525     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21526     if (SWIG_arg_fail(1)) SWIG_fail;
21527     {
21528         PyThreadState* __tstate = wxPyBeginAllowThreads();
21529         result = (double)(arg1)->GetPrinterScaleY();
21530
21531         wxPyEndAllowThreads(__tstate);
21532         if (PyErr_Occurred()) SWIG_fail;
21533     }
21534     {
21535         resultobj = SWIG_From_double((double)(result));
21536     }
21537     return resultobj;
21538     fail:
21539     return NULL;
21540 }
21541
21542
21543 static PyObject *_wrap_PrintData_GetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21544     PyObject *resultobj;
21545     wxPrintData *arg1 = (wxPrintData *) 0 ;
21546     long result;
21547     PyObject * obj0 = 0 ;
21548     char *kwnames[] = {
21549         (char *) "self", NULL
21550     };
21551
21552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateX",kwnames,&obj0)) goto fail;
21553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21554     if (SWIG_arg_fail(1)) SWIG_fail;
21555     {
21556         PyThreadState* __tstate = wxPyBeginAllowThreads();
21557         result = (long)(arg1)->GetPrinterTranslateX();
21558
21559         wxPyEndAllowThreads(__tstate);
21560         if (PyErr_Occurred()) SWIG_fail;
21561     }
21562     {
21563         resultobj = SWIG_From_long((long)(result));
21564     }
21565     return resultobj;
21566     fail:
21567     return NULL;
21568 }
21569
21570
21571 static PyObject *_wrap_PrintData_GetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21572     PyObject *resultobj;
21573     wxPrintData *arg1 = (wxPrintData *) 0 ;
21574     long result;
21575     PyObject * obj0 = 0 ;
21576     char *kwnames[] = {
21577         (char *) "self", NULL
21578     };
21579
21580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateY",kwnames,&obj0)) goto fail;
21581     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21582     if (SWIG_arg_fail(1)) SWIG_fail;
21583     {
21584         PyThreadState* __tstate = wxPyBeginAllowThreads();
21585         result = (long)(arg1)->GetPrinterTranslateY();
21586
21587         wxPyEndAllowThreads(__tstate);
21588         if (PyErr_Occurred()) SWIG_fail;
21589     }
21590     {
21591         resultobj = SWIG_From_long((long)(result));
21592     }
21593     return resultobj;
21594     fail:
21595     return NULL;
21596 }
21597
21598
21599 static PyObject *_wrap_PrintData_SetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21600     PyObject *resultobj;
21601     wxPrintData *arg1 = (wxPrintData *) 0 ;
21602     wxString *arg2 = 0 ;
21603     bool temp2 = false ;
21604     PyObject * obj0 = 0 ;
21605     PyObject * obj1 = 0 ;
21606     char *kwnames[] = {
21607         (char *) "self",(char *) "command", NULL
21608     };
21609
21610     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterCommand",kwnames,&obj0,&obj1)) goto fail;
21611     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21612     if (SWIG_arg_fail(1)) SWIG_fail;
21613     {
21614         arg2 = wxString_in_helper(obj1);
21615         if (arg2 == NULL) SWIG_fail;
21616         temp2 = true;
21617     }
21618     {
21619         PyThreadState* __tstate = wxPyBeginAllowThreads();
21620         (arg1)->SetPrinterCommand((wxString const &)*arg2);
21621
21622         wxPyEndAllowThreads(__tstate);
21623         if (PyErr_Occurred()) SWIG_fail;
21624     }
21625     Py_INCREF(Py_None); resultobj = Py_None;
21626     {
21627         if (temp2)
21628         delete arg2;
21629     }
21630     return resultobj;
21631     fail:
21632     {
21633         if (temp2)
21634         delete arg2;
21635     }
21636     return NULL;
21637 }
21638
21639
21640 static PyObject *_wrap_PrintData_SetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21641     PyObject *resultobj;
21642     wxPrintData *arg1 = (wxPrintData *) 0 ;
21643     wxString *arg2 = 0 ;
21644     bool temp2 = false ;
21645     PyObject * obj0 = 0 ;
21646     PyObject * obj1 = 0 ;
21647     char *kwnames[] = {
21648         (char *) "self",(char *) "options", NULL
21649     };
21650
21651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterOptions",kwnames,&obj0,&obj1)) goto fail;
21652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21653     if (SWIG_arg_fail(1)) SWIG_fail;
21654     {
21655         arg2 = wxString_in_helper(obj1);
21656         if (arg2 == NULL) SWIG_fail;
21657         temp2 = true;
21658     }
21659     {
21660         PyThreadState* __tstate = wxPyBeginAllowThreads();
21661         (arg1)->SetPrinterOptions((wxString const &)*arg2);
21662
21663         wxPyEndAllowThreads(__tstate);
21664         if (PyErr_Occurred()) SWIG_fail;
21665     }
21666     Py_INCREF(Py_None); resultobj = Py_None;
21667     {
21668         if (temp2)
21669         delete arg2;
21670     }
21671     return resultobj;
21672     fail:
21673     {
21674         if (temp2)
21675         delete arg2;
21676     }
21677     return NULL;
21678 }
21679
21680
21681 static PyObject *_wrap_PrintData_SetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21682     PyObject *resultobj;
21683     wxPrintData *arg1 = (wxPrintData *) 0 ;
21684     wxString *arg2 = 0 ;
21685     bool temp2 = false ;
21686     PyObject * obj0 = 0 ;
21687     PyObject * obj1 = 0 ;
21688     char *kwnames[] = {
21689         (char *) "self",(char *) "command", NULL
21690     };
21691
21692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPreviewCommand",kwnames,&obj0,&obj1)) goto fail;
21693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21694     if (SWIG_arg_fail(1)) SWIG_fail;
21695     {
21696         arg2 = wxString_in_helper(obj1);
21697         if (arg2 == NULL) SWIG_fail;
21698         temp2 = true;
21699     }
21700     {
21701         PyThreadState* __tstate = wxPyBeginAllowThreads();
21702         (arg1)->SetPreviewCommand((wxString const &)*arg2);
21703
21704         wxPyEndAllowThreads(__tstate);
21705         if (PyErr_Occurred()) SWIG_fail;
21706     }
21707     Py_INCREF(Py_None); resultobj = Py_None;
21708     {
21709         if (temp2)
21710         delete arg2;
21711     }
21712     return resultobj;
21713     fail:
21714     {
21715         if (temp2)
21716         delete arg2;
21717     }
21718     return NULL;
21719 }
21720
21721
21722 static PyObject *_wrap_PrintData_SetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21723     PyObject *resultobj;
21724     wxPrintData *arg1 = (wxPrintData *) 0 ;
21725     wxString *arg2 = 0 ;
21726     bool temp2 = false ;
21727     PyObject * obj0 = 0 ;
21728     PyObject * obj1 = 0 ;
21729     char *kwnames[] = {
21730         (char *) "self",(char *) "path", NULL
21731     };
21732
21733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFontMetricPath",kwnames,&obj0,&obj1)) goto fail;
21734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21735     if (SWIG_arg_fail(1)) SWIG_fail;
21736     {
21737         arg2 = wxString_in_helper(obj1);
21738         if (arg2 == NULL) SWIG_fail;
21739         temp2 = true;
21740     }
21741     {
21742         PyThreadState* __tstate = wxPyBeginAllowThreads();
21743         (arg1)->SetFontMetricPath((wxString const &)*arg2);
21744
21745         wxPyEndAllowThreads(__tstate);
21746         if (PyErr_Occurred()) SWIG_fail;
21747     }
21748     Py_INCREF(Py_None); resultobj = Py_None;
21749     {
21750         if (temp2)
21751         delete arg2;
21752     }
21753     return resultobj;
21754     fail:
21755     {
21756         if (temp2)
21757         delete arg2;
21758     }
21759     return NULL;
21760 }
21761
21762
21763 static PyObject *_wrap_PrintData_SetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21764     PyObject *resultobj;
21765     wxPrintData *arg1 = (wxPrintData *) 0 ;
21766     double arg2 ;
21767     PyObject * obj0 = 0 ;
21768     PyObject * obj1 = 0 ;
21769     char *kwnames[] = {
21770         (char *) "self",(char *) "x", NULL
21771     };
21772
21773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleX",kwnames,&obj0,&obj1)) goto fail;
21774     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21775     if (SWIG_arg_fail(1)) SWIG_fail;
21776     {
21777         arg2 = (double)(SWIG_As_double(obj1));
21778         if (SWIG_arg_fail(2)) SWIG_fail;
21779     }
21780     {
21781         PyThreadState* __tstate = wxPyBeginAllowThreads();
21782         (arg1)->SetPrinterScaleX(arg2);
21783
21784         wxPyEndAllowThreads(__tstate);
21785         if (PyErr_Occurred()) SWIG_fail;
21786     }
21787     Py_INCREF(Py_None); resultobj = Py_None;
21788     return resultobj;
21789     fail:
21790     return NULL;
21791 }
21792
21793
21794 static PyObject *_wrap_PrintData_SetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21795     PyObject *resultobj;
21796     wxPrintData *arg1 = (wxPrintData *) 0 ;
21797     double arg2 ;
21798     PyObject * obj0 = 0 ;
21799     PyObject * obj1 = 0 ;
21800     char *kwnames[] = {
21801         (char *) "self",(char *) "y", NULL
21802     };
21803
21804     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleY",kwnames,&obj0,&obj1)) goto fail;
21805     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21806     if (SWIG_arg_fail(1)) SWIG_fail;
21807     {
21808         arg2 = (double)(SWIG_As_double(obj1));
21809         if (SWIG_arg_fail(2)) SWIG_fail;
21810     }
21811     {
21812         PyThreadState* __tstate = wxPyBeginAllowThreads();
21813         (arg1)->SetPrinterScaleY(arg2);
21814
21815         wxPyEndAllowThreads(__tstate);
21816         if (PyErr_Occurred()) SWIG_fail;
21817     }
21818     Py_INCREF(Py_None); resultobj = Py_None;
21819     return resultobj;
21820     fail:
21821     return NULL;
21822 }
21823
21824
21825 static PyObject *_wrap_PrintData_SetPrinterScaling(PyObject *, PyObject *args, PyObject *kwargs) {
21826     PyObject *resultobj;
21827     wxPrintData *arg1 = (wxPrintData *) 0 ;
21828     double arg2 ;
21829     double arg3 ;
21830     PyObject * obj0 = 0 ;
21831     PyObject * obj1 = 0 ;
21832     PyObject * obj2 = 0 ;
21833     char *kwnames[] = {
21834         (char *) "self",(char *) "x",(char *) "y", NULL
21835     };
21836
21837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterScaling",kwnames,&obj0,&obj1,&obj2)) goto fail;
21838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21839     if (SWIG_arg_fail(1)) SWIG_fail;
21840     {
21841         arg2 = (double)(SWIG_As_double(obj1));
21842         if (SWIG_arg_fail(2)) SWIG_fail;
21843     }
21844     {
21845         arg3 = (double)(SWIG_As_double(obj2));
21846         if (SWIG_arg_fail(3)) SWIG_fail;
21847     }
21848     {
21849         PyThreadState* __tstate = wxPyBeginAllowThreads();
21850         (arg1)->SetPrinterScaling(arg2,arg3);
21851
21852         wxPyEndAllowThreads(__tstate);
21853         if (PyErr_Occurred()) SWIG_fail;
21854     }
21855     Py_INCREF(Py_None); resultobj = Py_None;
21856     return resultobj;
21857     fail:
21858     return NULL;
21859 }
21860
21861
21862 static PyObject *_wrap_PrintData_SetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21863     PyObject *resultobj;
21864     wxPrintData *arg1 = (wxPrintData *) 0 ;
21865     long arg2 ;
21866     PyObject * obj0 = 0 ;
21867     PyObject * obj1 = 0 ;
21868     char *kwnames[] = {
21869         (char *) "self",(char *) "x", NULL
21870     };
21871
21872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateX",kwnames,&obj0,&obj1)) goto fail;
21873     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21874     if (SWIG_arg_fail(1)) SWIG_fail;
21875     {
21876         arg2 = (long)(SWIG_As_long(obj1));
21877         if (SWIG_arg_fail(2)) SWIG_fail;
21878     }
21879     {
21880         PyThreadState* __tstate = wxPyBeginAllowThreads();
21881         (arg1)->SetPrinterTranslateX(arg2);
21882
21883         wxPyEndAllowThreads(__tstate);
21884         if (PyErr_Occurred()) SWIG_fail;
21885     }
21886     Py_INCREF(Py_None); resultobj = Py_None;
21887     return resultobj;
21888     fail:
21889     return NULL;
21890 }
21891
21892
21893 static PyObject *_wrap_PrintData_SetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21894     PyObject *resultobj;
21895     wxPrintData *arg1 = (wxPrintData *) 0 ;
21896     long arg2 ;
21897     PyObject * obj0 = 0 ;
21898     PyObject * obj1 = 0 ;
21899     char *kwnames[] = {
21900         (char *) "self",(char *) "y", NULL
21901     };
21902
21903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateY",kwnames,&obj0,&obj1)) goto fail;
21904     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21905     if (SWIG_arg_fail(1)) SWIG_fail;
21906     {
21907         arg2 = (long)(SWIG_As_long(obj1));
21908         if (SWIG_arg_fail(2)) SWIG_fail;
21909     }
21910     {
21911         PyThreadState* __tstate = wxPyBeginAllowThreads();
21912         (arg1)->SetPrinterTranslateY(arg2);
21913
21914         wxPyEndAllowThreads(__tstate);
21915         if (PyErr_Occurred()) SWIG_fail;
21916     }
21917     Py_INCREF(Py_None); resultobj = Py_None;
21918     return resultobj;
21919     fail:
21920     return NULL;
21921 }
21922
21923
21924 static PyObject *_wrap_PrintData_SetPrinterTranslation(PyObject *, PyObject *args, PyObject *kwargs) {
21925     PyObject *resultobj;
21926     wxPrintData *arg1 = (wxPrintData *) 0 ;
21927     long arg2 ;
21928     long arg3 ;
21929     PyObject * obj0 = 0 ;
21930     PyObject * obj1 = 0 ;
21931     PyObject * obj2 = 0 ;
21932     char *kwnames[] = {
21933         (char *) "self",(char *) "x",(char *) "y", NULL
21934     };
21935
21936     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterTranslation",kwnames,&obj0,&obj1,&obj2)) goto fail;
21937     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21938     if (SWIG_arg_fail(1)) SWIG_fail;
21939     {
21940         arg2 = (long)(SWIG_As_long(obj1));
21941         if (SWIG_arg_fail(2)) SWIG_fail;
21942     }
21943     {
21944         arg3 = (long)(SWIG_As_long(obj2));
21945         if (SWIG_arg_fail(3)) SWIG_fail;
21946     }
21947     {
21948         PyThreadState* __tstate = wxPyBeginAllowThreads();
21949         (arg1)->SetPrinterTranslation(arg2,arg3);
21950
21951         wxPyEndAllowThreads(__tstate);
21952         if (PyErr_Occurred()) SWIG_fail;
21953     }
21954     Py_INCREF(Py_None); resultobj = Py_None;
21955     return resultobj;
21956     fail:
21957     return NULL;
21958 }
21959
21960
21961 static PyObject * PrintData_swigregister(PyObject *, PyObject *args) {
21962     PyObject *obj;
21963     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21964     SWIG_TypeClientData(SWIGTYPE_p_wxPrintData, obj);
21965     Py_INCREF(obj);
21966     return Py_BuildValue((char *)"");
21967 }
21968 static PyObject *_wrap_new_PageSetupDialogData__SWIG_0(PyObject *, PyObject *args) {
21969     PyObject *resultobj;
21970     wxPageSetupDialogData *result;
21971
21972     if(!PyArg_ParseTuple(args,(char *)":new_PageSetupDialogData")) goto fail;
21973     {
21974         PyThreadState* __tstate = wxPyBeginAllowThreads();
21975         result = (wxPageSetupDialogData *)new wxPageSetupDialogData();
21976
21977         wxPyEndAllowThreads(__tstate);
21978         if (PyErr_Occurred()) SWIG_fail;
21979     }
21980     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21981     return resultobj;
21982     fail:
21983     return NULL;
21984 }
21985
21986
21987 static PyObject *_wrap_new_PageSetupDialogData__SWIG_1(PyObject *, PyObject *args) {
21988     PyObject *resultobj;
21989     wxPageSetupDialogData *arg1 = 0 ;
21990     wxPageSetupDialogData *result;
21991     PyObject * obj0 = 0 ;
21992
21993     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21994     {
21995         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21996         if (SWIG_arg_fail(1)) SWIG_fail;
21997         if (arg1 == NULL) {
21998             SWIG_null_ref("wxPageSetupDialogData");
21999         }
22000         if (SWIG_arg_fail(1)) SWIG_fail;
22001     }
22002     {
22003         PyThreadState* __tstate = wxPyBeginAllowThreads();
22004         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPageSetupDialogData const &)*arg1);
22005
22006         wxPyEndAllowThreads(__tstate);
22007         if (PyErr_Occurred()) SWIG_fail;
22008     }
22009     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
22010     return resultobj;
22011     fail:
22012     return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_new_PageSetupDialogData__SWIG_2(PyObject *, PyObject *args) {
22017     PyObject *resultobj;
22018     wxPrintData *arg1 = 0 ;
22019     wxPageSetupDialogData *result;
22020     PyObject * obj0 = 0 ;
22021
22022     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
22023     {
22024         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22025         if (SWIG_arg_fail(1)) SWIG_fail;
22026         if (arg1 == NULL) {
22027             SWIG_null_ref("wxPrintData");
22028         }
22029         if (SWIG_arg_fail(1)) SWIG_fail;
22030     }
22031     {
22032         PyThreadState* __tstate = wxPyBeginAllowThreads();
22033         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPrintData const &)*arg1);
22034
22035         wxPyEndAllowThreads(__tstate);
22036         if (PyErr_Occurred()) SWIG_fail;
22037     }
22038     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
22039     return resultobj;
22040     fail:
22041     return NULL;
22042 }
22043
22044
22045 static PyObject *_wrap_new_PageSetupDialogData(PyObject *self, PyObject *args) {
22046     int argc;
22047     PyObject *argv[2];
22048     int ii;
22049
22050     argc = PyObject_Length(args);
22051     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
22052         argv[ii] = PyTuple_GetItem(args,ii);
22053     }
22054     if (argc == 0) {
22055         return _wrap_new_PageSetupDialogData__SWIG_0(self,args);
22056     }
22057     if (argc == 1) {
22058         int _v;
22059         {
22060             void *ptr = 0;
22061             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPageSetupDialogData, 0) == -1) {
22062                 _v = 0;
22063                 PyErr_Clear();
22064             } else {
22065                 _v = (ptr != 0);
22066             }
22067         }
22068         if (_v) {
22069             return _wrap_new_PageSetupDialogData__SWIG_1(self,args);
22070         }
22071     }
22072     if (argc == 1) {
22073         int _v;
22074         {
22075             void *ptr = 0;
22076             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
22077                 _v = 0;
22078                 PyErr_Clear();
22079             } else {
22080                 _v = (ptr != 0);
22081             }
22082         }
22083         if (_v) {
22084             return _wrap_new_PageSetupDialogData__SWIG_2(self,args);
22085         }
22086     }
22087
22088     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PageSetupDialogData'");
22089     return NULL;
22090 }
22091
22092
22093 static PyObject *_wrap_delete_PageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
22094     PyObject *resultobj;
22095     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22096     PyObject * obj0 = 0 ;
22097     char *kwnames[] = {
22098         (char *) "self", NULL
22099     };
22100
22101     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PageSetupDialogData",kwnames,&obj0)) goto fail;
22102     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22103     if (SWIG_arg_fail(1)) SWIG_fail;
22104     {
22105         PyThreadState* __tstate = wxPyBeginAllowThreads();
22106         delete arg1;
22107
22108         wxPyEndAllowThreads(__tstate);
22109         if (PyErr_Occurred()) SWIG_fail;
22110     }
22111     Py_INCREF(Py_None); resultobj = Py_None;
22112     return resultobj;
22113     fail:
22114     return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_PageSetupDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22119     PyObject *resultobj;
22120     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22121     bool arg2 ;
22122     PyObject * obj0 = 0 ;
22123     PyObject * obj1 = 0 ;
22124     char *kwnames[] = {
22125         (char *) "self",(char *) "flag", NULL
22126     };
22127
22128     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
22129     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22130     if (SWIG_arg_fail(1)) SWIG_fail;
22131     {
22132         arg2 = (bool)(SWIG_As_bool(obj1));
22133         if (SWIG_arg_fail(2)) SWIG_fail;
22134     }
22135     {
22136         PyThreadState* __tstate = wxPyBeginAllowThreads();
22137         (arg1)->EnableHelp(arg2);
22138
22139         wxPyEndAllowThreads(__tstate);
22140         if (PyErr_Occurred()) SWIG_fail;
22141     }
22142     Py_INCREF(Py_None); resultobj = Py_None;
22143     return resultobj;
22144     fail:
22145     return NULL;
22146 }
22147
22148
22149 static PyObject *_wrap_PageSetupDialogData_EnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22150     PyObject *resultobj;
22151     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22152     bool arg2 ;
22153     PyObject * obj0 = 0 ;
22154     PyObject * obj1 = 0 ;
22155     char *kwnames[] = {
22156         (char *) "self",(char *) "flag", NULL
22157     };
22158
22159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableMargins",kwnames,&obj0,&obj1)) goto fail;
22160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22161     if (SWIG_arg_fail(1)) SWIG_fail;
22162     {
22163         arg2 = (bool)(SWIG_As_bool(obj1));
22164         if (SWIG_arg_fail(2)) SWIG_fail;
22165     }
22166     {
22167         PyThreadState* __tstate = wxPyBeginAllowThreads();
22168         (arg1)->EnableMargins(arg2);
22169
22170         wxPyEndAllowThreads(__tstate);
22171         if (PyErr_Occurred()) SWIG_fail;
22172     }
22173     Py_INCREF(Py_None); resultobj = Py_None;
22174     return resultobj;
22175     fail:
22176     return NULL;
22177 }
22178
22179
22180 static PyObject *_wrap_PageSetupDialogData_EnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22181     PyObject *resultobj;
22182     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22183     bool arg2 ;
22184     PyObject * obj0 = 0 ;
22185     PyObject * obj1 = 0 ;
22186     char *kwnames[] = {
22187         (char *) "self",(char *) "flag", NULL
22188     };
22189
22190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableOrientation",kwnames,&obj0,&obj1)) goto fail;
22191     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22192     if (SWIG_arg_fail(1)) SWIG_fail;
22193     {
22194         arg2 = (bool)(SWIG_As_bool(obj1));
22195         if (SWIG_arg_fail(2)) SWIG_fail;
22196     }
22197     {
22198         PyThreadState* __tstate = wxPyBeginAllowThreads();
22199         (arg1)->EnableOrientation(arg2);
22200
22201         wxPyEndAllowThreads(__tstate);
22202         if (PyErr_Occurred()) SWIG_fail;
22203     }
22204     Py_INCREF(Py_None); resultobj = Py_None;
22205     return resultobj;
22206     fail:
22207     return NULL;
22208 }
22209
22210
22211 static PyObject *_wrap_PageSetupDialogData_EnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22212     PyObject *resultobj;
22213     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22214     bool arg2 ;
22215     PyObject * obj0 = 0 ;
22216     PyObject * obj1 = 0 ;
22217     char *kwnames[] = {
22218         (char *) "self",(char *) "flag", NULL
22219     };
22220
22221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePaper",kwnames,&obj0,&obj1)) goto fail;
22222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22223     if (SWIG_arg_fail(1)) SWIG_fail;
22224     {
22225         arg2 = (bool)(SWIG_As_bool(obj1));
22226         if (SWIG_arg_fail(2)) SWIG_fail;
22227     }
22228     {
22229         PyThreadState* __tstate = wxPyBeginAllowThreads();
22230         (arg1)->EnablePaper(arg2);
22231
22232         wxPyEndAllowThreads(__tstate);
22233         if (PyErr_Occurred()) SWIG_fail;
22234     }
22235     Py_INCREF(Py_None); resultobj = Py_None;
22236     return resultobj;
22237     fail:
22238     return NULL;
22239 }
22240
22241
22242 static PyObject *_wrap_PageSetupDialogData_EnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22243     PyObject *resultobj;
22244     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22245     bool arg2 ;
22246     PyObject * obj0 = 0 ;
22247     PyObject * obj1 = 0 ;
22248     char *kwnames[] = {
22249         (char *) "self",(char *) "flag", NULL
22250     };
22251
22252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePrinter",kwnames,&obj0,&obj1)) goto fail;
22253     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22254     if (SWIG_arg_fail(1)) SWIG_fail;
22255     {
22256         arg2 = (bool)(SWIG_As_bool(obj1));
22257         if (SWIG_arg_fail(2)) SWIG_fail;
22258     }
22259     {
22260         PyThreadState* __tstate = wxPyBeginAllowThreads();
22261         (arg1)->EnablePrinter(arg2);
22262
22263         wxPyEndAllowThreads(__tstate);
22264         if (PyErr_Occurred()) SWIG_fail;
22265     }
22266     Py_INCREF(Py_None); resultobj = Py_None;
22267     return resultobj;
22268     fail:
22269     return NULL;
22270 }
22271
22272
22273 static PyObject *_wrap_PageSetupDialogData_GetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22274     PyObject *resultobj;
22275     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22276     bool result;
22277     PyObject * obj0 = 0 ;
22278     char *kwnames[] = {
22279         (char *) "self", NULL
22280     };
22281
22282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultMinMargins",kwnames,&obj0)) goto fail;
22283     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22284     if (SWIG_arg_fail(1)) SWIG_fail;
22285     {
22286         PyThreadState* __tstate = wxPyBeginAllowThreads();
22287         result = (bool)(arg1)->GetDefaultMinMargins();
22288
22289         wxPyEndAllowThreads(__tstate);
22290         if (PyErr_Occurred()) SWIG_fail;
22291     }
22292     {
22293         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22294     }
22295     return resultobj;
22296     fail:
22297     return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_PageSetupDialogData_GetEnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22302     PyObject *resultobj;
22303     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22304     bool result;
22305     PyObject * obj0 = 0 ;
22306     char *kwnames[] = {
22307         (char *) "self", NULL
22308     };
22309
22310     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableMargins",kwnames,&obj0)) goto fail;
22311     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22312     if (SWIG_arg_fail(1)) SWIG_fail;
22313     {
22314         PyThreadState* __tstate = wxPyBeginAllowThreads();
22315         result = (bool)(arg1)->GetEnableMargins();
22316
22317         wxPyEndAllowThreads(__tstate);
22318         if (PyErr_Occurred()) SWIG_fail;
22319     }
22320     {
22321         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322     }
22323     return resultobj;
22324     fail:
22325     return NULL;
22326 }
22327
22328
22329 static PyObject *_wrap_PageSetupDialogData_GetEnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22330     PyObject *resultobj;
22331     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22332     bool result;
22333     PyObject * obj0 = 0 ;
22334     char *kwnames[] = {
22335         (char *) "self", NULL
22336     };
22337
22338     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableOrientation",kwnames,&obj0)) goto fail;
22339     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22340     if (SWIG_arg_fail(1)) SWIG_fail;
22341     {
22342         PyThreadState* __tstate = wxPyBeginAllowThreads();
22343         result = (bool)(arg1)->GetEnableOrientation();
22344
22345         wxPyEndAllowThreads(__tstate);
22346         if (PyErr_Occurred()) SWIG_fail;
22347     }
22348     {
22349         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22350     }
22351     return resultobj;
22352     fail:
22353     return NULL;
22354 }
22355
22356
22357 static PyObject *_wrap_PageSetupDialogData_GetEnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22358     PyObject *resultobj;
22359     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22360     bool result;
22361     PyObject * obj0 = 0 ;
22362     char *kwnames[] = {
22363         (char *) "self", NULL
22364     };
22365
22366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePaper",kwnames,&obj0)) goto fail;
22367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22368     if (SWIG_arg_fail(1)) SWIG_fail;
22369     {
22370         PyThreadState* __tstate = wxPyBeginAllowThreads();
22371         result = (bool)(arg1)->GetEnablePaper();
22372
22373         wxPyEndAllowThreads(__tstate);
22374         if (PyErr_Occurred()) SWIG_fail;
22375     }
22376     {
22377         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22378     }
22379     return resultobj;
22380     fail:
22381     return NULL;
22382 }
22383
22384
22385 static PyObject *_wrap_PageSetupDialogData_GetEnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22386     PyObject *resultobj;
22387     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22388     bool result;
22389     PyObject * obj0 = 0 ;
22390     char *kwnames[] = {
22391         (char *) "self", NULL
22392     };
22393
22394     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePrinter",kwnames,&obj0)) goto fail;
22395     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22396     if (SWIG_arg_fail(1)) SWIG_fail;
22397     {
22398         PyThreadState* __tstate = wxPyBeginAllowThreads();
22399         result = (bool)(arg1)->GetEnablePrinter();
22400
22401         wxPyEndAllowThreads(__tstate);
22402         if (PyErr_Occurred()) SWIG_fail;
22403     }
22404     {
22405         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22406     }
22407     return resultobj;
22408     fail:
22409     return NULL;
22410 }
22411
22412
22413 static PyObject *_wrap_PageSetupDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22414     PyObject *resultobj;
22415     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22416     bool result;
22417     PyObject * obj0 = 0 ;
22418     char *kwnames[] = {
22419         (char *) "self", NULL
22420     };
22421
22422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
22423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22424     if (SWIG_arg_fail(1)) SWIG_fail;
22425     {
22426         PyThreadState* __tstate = wxPyBeginAllowThreads();
22427         result = (bool)(arg1)->GetEnableHelp();
22428
22429         wxPyEndAllowThreads(__tstate);
22430         if (PyErr_Occurred()) SWIG_fail;
22431     }
22432     {
22433         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22434     }
22435     return resultobj;
22436     fail:
22437     return NULL;
22438 }
22439
22440
22441 static PyObject *_wrap_PageSetupDialogData_GetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22442     PyObject *resultobj;
22443     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22444     bool result;
22445     PyObject * obj0 = 0 ;
22446     char *kwnames[] = {
22447         (char *) "self", NULL
22448     };
22449
22450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultInfo",kwnames,&obj0)) goto fail;
22451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22452     if (SWIG_arg_fail(1)) SWIG_fail;
22453     {
22454         PyThreadState* __tstate = wxPyBeginAllowThreads();
22455         result = (bool)(arg1)->GetDefaultInfo();
22456
22457         wxPyEndAllowThreads(__tstate);
22458         if (PyErr_Occurred()) SWIG_fail;
22459     }
22460     {
22461         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22462     }
22463     return resultobj;
22464     fail:
22465     return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_PageSetupDialogData_GetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22470     PyObject *resultobj;
22471     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22472     wxPoint result;
22473     PyObject * obj0 = 0 ;
22474     char *kwnames[] = {
22475         (char *) "self", NULL
22476     };
22477
22478     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginTopLeft",kwnames,&obj0)) goto fail;
22479     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22480     if (SWIG_arg_fail(1)) SWIG_fail;
22481     {
22482         PyThreadState* __tstate = wxPyBeginAllowThreads();
22483         result = (arg1)->GetMarginTopLeft();
22484
22485         wxPyEndAllowThreads(__tstate);
22486         if (PyErr_Occurred()) SWIG_fail;
22487     }
22488     {
22489         wxPoint * resultptr;
22490         resultptr = new wxPoint((wxPoint &)(result));
22491         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22492     }
22493     return resultobj;
22494     fail:
22495     return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_PageSetupDialogData_GetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22500     PyObject *resultobj;
22501     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22502     wxPoint result;
22503     PyObject * obj0 = 0 ;
22504     char *kwnames[] = {
22505         (char *) "self", NULL
22506     };
22507
22508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginBottomRight",kwnames,&obj0)) goto fail;
22509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22510     if (SWIG_arg_fail(1)) SWIG_fail;
22511     {
22512         PyThreadState* __tstate = wxPyBeginAllowThreads();
22513         result = (arg1)->GetMarginBottomRight();
22514
22515         wxPyEndAllowThreads(__tstate);
22516         if (PyErr_Occurred()) SWIG_fail;
22517     }
22518     {
22519         wxPoint * resultptr;
22520         resultptr = new wxPoint((wxPoint &)(result));
22521         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22522     }
22523     return resultobj;
22524     fail:
22525     return NULL;
22526 }
22527
22528
22529 static PyObject *_wrap_PageSetupDialogData_GetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22530     PyObject *resultobj;
22531     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22532     wxPoint result;
22533     PyObject * obj0 = 0 ;
22534     char *kwnames[] = {
22535         (char *) "self", NULL
22536     };
22537
22538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginTopLeft",kwnames,&obj0)) goto fail;
22539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22540     if (SWIG_arg_fail(1)) SWIG_fail;
22541     {
22542         PyThreadState* __tstate = wxPyBeginAllowThreads();
22543         result = (arg1)->GetMinMarginTopLeft();
22544
22545         wxPyEndAllowThreads(__tstate);
22546         if (PyErr_Occurred()) SWIG_fail;
22547     }
22548     {
22549         wxPoint * resultptr;
22550         resultptr = new wxPoint((wxPoint &)(result));
22551         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22552     }
22553     return resultobj;
22554     fail:
22555     return NULL;
22556 }
22557
22558
22559 static PyObject *_wrap_PageSetupDialogData_GetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22560     PyObject *resultobj;
22561     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22562     wxPoint result;
22563     PyObject * obj0 = 0 ;
22564     char *kwnames[] = {
22565         (char *) "self", NULL
22566     };
22567
22568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginBottomRight",kwnames,&obj0)) goto fail;
22569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22570     if (SWIG_arg_fail(1)) SWIG_fail;
22571     {
22572         PyThreadState* __tstate = wxPyBeginAllowThreads();
22573         result = (arg1)->GetMinMarginBottomRight();
22574
22575         wxPyEndAllowThreads(__tstate);
22576         if (PyErr_Occurred()) SWIG_fail;
22577     }
22578     {
22579         wxPoint * resultptr;
22580         resultptr = new wxPoint((wxPoint &)(result));
22581         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22582     }
22583     return resultobj;
22584     fail:
22585     return NULL;
22586 }
22587
22588
22589 static PyObject *_wrap_PageSetupDialogData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22590     PyObject *resultobj;
22591     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22592     wxPaperSize result;
22593     PyObject * obj0 = 0 ;
22594     char *kwnames[] = {
22595         (char *) "self", NULL
22596     };
22597
22598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperId",kwnames,&obj0)) goto fail;
22599     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22600     if (SWIG_arg_fail(1)) SWIG_fail;
22601     {
22602         PyThreadState* __tstate = wxPyBeginAllowThreads();
22603         result = (wxPaperSize)(arg1)->GetPaperId();
22604
22605         wxPyEndAllowThreads(__tstate);
22606         if (PyErr_Occurred()) SWIG_fail;
22607     }
22608     resultobj = SWIG_From_int((result));
22609     return resultobj;
22610     fail:
22611     return NULL;
22612 }
22613
22614
22615 static PyObject *_wrap_PageSetupDialogData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22616     PyObject *resultobj;
22617     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22618     wxSize result;
22619     PyObject * obj0 = 0 ;
22620     char *kwnames[] = {
22621         (char *) "self", NULL
22622     };
22623
22624     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperSize",kwnames,&obj0)) goto fail;
22625     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22626     if (SWIG_arg_fail(1)) SWIG_fail;
22627     {
22628         PyThreadState* __tstate = wxPyBeginAllowThreads();
22629         result = (arg1)->GetPaperSize();
22630
22631         wxPyEndAllowThreads(__tstate);
22632         if (PyErr_Occurred()) SWIG_fail;
22633     }
22634     {
22635         wxSize * resultptr;
22636         resultptr = new wxSize((wxSize &)(result));
22637         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
22638     }
22639     return resultobj;
22640     fail:
22641     return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_PageSetupDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22646     PyObject *resultobj;
22647     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22648     wxPrintData *result;
22649     PyObject * obj0 = 0 ;
22650     char *kwnames[] = {
22651         (char *) "self", NULL
22652     };
22653
22654     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPrintData",kwnames,&obj0)) goto fail;
22655     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22656     if (SWIG_arg_fail(1)) SWIG_fail;
22657     {
22658         PyThreadState* __tstate = wxPyBeginAllowThreads();
22659         {
22660             wxPrintData &_result_ref = (arg1)->GetPrintData();
22661             result = (wxPrintData *) &_result_ref;
22662         }
22663
22664         wxPyEndAllowThreads(__tstate);
22665         if (PyErr_Occurred()) SWIG_fail;
22666     }
22667     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
22668     return resultobj;
22669     fail:
22670     return NULL;
22671 }
22672
22673
22674 static PyObject *_wrap_PageSetupDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
22675     PyObject *resultobj;
22676     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22677     bool result;
22678     PyObject * obj0 = 0 ;
22679     char *kwnames[] = {
22680         (char *) "self", NULL
22681     };
22682
22683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_Ok",kwnames,&obj0)) goto fail;
22684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22685     if (SWIG_arg_fail(1)) SWIG_fail;
22686     {
22687         PyThreadState* __tstate = wxPyBeginAllowThreads();
22688         result = (bool)(arg1)->Ok();
22689
22690         wxPyEndAllowThreads(__tstate);
22691         if (PyErr_Occurred()) SWIG_fail;
22692     }
22693     {
22694         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22695     }
22696     return resultobj;
22697     fail:
22698     return NULL;
22699 }
22700
22701
22702 static PyObject *_wrap_PageSetupDialogData_SetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22703     PyObject *resultobj;
22704     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22705     bool arg2 ;
22706     PyObject * obj0 = 0 ;
22707     PyObject * obj1 = 0 ;
22708     char *kwnames[] = {
22709         (char *) "self",(char *) "flag", NULL
22710     };
22711
22712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultInfo",kwnames,&obj0,&obj1)) goto fail;
22713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22714     if (SWIG_arg_fail(1)) SWIG_fail;
22715     {
22716         arg2 = (bool)(SWIG_As_bool(obj1));
22717         if (SWIG_arg_fail(2)) SWIG_fail;
22718     }
22719     {
22720         PyThreadState* __tstate = wxPyBeginAllowThreads();
22721         (arg1)->SetDefaultInfo(arg2);
22722
22723         wxPyEndAllowThreads(__tstate);
22724         if (PyErr_Occurred()) SWIG_fail;
22725     }
22726     Py_INCREF(Py_None); resultobj = Py_None;
22727     return resultobj;
22728     fail:
22729     return NULL;
22730 }
22731
22732
22733 static PyObject *_wrap_PageSetupDialogData_SetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22734     PyObject *resultobj;
22735     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22736     bool arg2 ;
22737     PyObject * obj0 = 0 ;
22738     PyObject * obj1 = 0 ;
22739     char *kwnames[] = {
22740         (char *) "self",(char *) "flag", NULL
22741     };
22742
22743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultMinMargins",kwnames,&obj0,&obj1)) goto fail;
22744     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22745     if (SWIG_arg_fail(1)) SWIG_fail;
22746     {
22747         arg2 = (bool)(SWIG_As_bool(obj1));
22748         if (SWIG_arg_fail(2)) SWIG_fail;
22749     }
22750     {
22751         PyThreadState* __tstate = wxPyBeginAllowThreads();
22752         (arg1)->SetDefaultMinMargins(arg2);
22753
22754         wxPyEndAllowThreads(__tstate);
22755         if (PyErr_Occurred()) SWIG_fail;
22756     }
22757     Py_INCREF(Py_None); resultobj = Py_None;
22758     return resultobj;
22759     fail:
22760     return NULL;
22761 }
22762
22763
22764 static PyObject *_wrap_PageSetupDialogData_SetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22765     PyObject *resultobj;
22766     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22767     wxPoint *arg2 = 0 ;
22768     wxPoint temp2 ;
22769     PyObject * obj0 = 0 ;
22770     PyObject * obj1 = 0 ;
22771     char *kwnames[] = {
22772         (char *) "self",(char *) "pt", NULL
22773     };
22774
22775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22776     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22777     if (SWIG_arg_fail(1)) SWIG_fail;
22778     {
22779         arg2 = &temp2;
22780         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22781     }
22782     {
22783         PyThreadState* __tstate = wxPyBeginAllowThreads();
22784         (arg1)->SetMarginTopLeft((wxPoint const &)*arg2);
22785
22786         wxPyEndAllowThreads(__tstate);
22787         if (PyErr_Occurred()) SWIG_fail;
22788     }
22789     Py_INCREF(Py_None); resultobj = Py_None;
22790     return resultobj;
22791     fail:
22792     return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PageSetupDialogData_SetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22797     PyObject *resultobj;
22798     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22799     wxPoint *arg2 = 0 ;
22800     wxPoint temp2 ;
22801     PyObject * obj0 = 0 ;
22802     PyObject * obj1 = 0 ;
22803     char *kwnames[] = {
22804         (char *) "self",(char *) "pt", NULL
22805     };
22806
22807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22809     if (SWIG_arg_fail(1)) SWIG_fail;
22810     {
22811         arg2 = &temp2;
22812         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22813     }
22814     {
22815         PyThreadState* __tstate = wxPyBeginAllowThreads();
22816         (arg1)->SetMarginBottomRight((wxPoint const &)*arg2);
22817
22818         wxPyEndAllowThreads(__tstate);
22819         if (PyErr_Occurred()) SWIG_fail;
22820     }
22821     Py_INCREF(Py_None); resultobj = Py_None;
22822     return resultobj;
22823     fail:
22824     return NULL;
22825 }
22826
22827
22828 static PyObject *_wrap_PageSetupDialogData_SetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22829     PyObject *resultobj;
22830     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22831     wxPoint *arg2 = 0 ;
22832     wxPoint temp2 ;
22833     PyObject * obj0 = 0 ;
22834     PyObject * obj1 = 0 ;
22835     char *kwnames[] = {
22836         (char *) "self",(char *) "pt", NULL
22837     };
22838
22839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22841     if (SWIG_arg_fail(1)) SWIG_fail;
22842     {
22843         arg2 = &temp2;
22844         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22845     }
22846     {
22847         PyThreadState* __tstate = wxPyBeginAllowThreads();
22848         (arg1)->SetMinMarginTopLeft((wxPoint const &)*arg2);
22849
22850         wxPyEndAllowThreads(__tstate);
22851         if (PyErr_Occurred()) SWIG_fail;
22852     }
22853     Py_INCREF(Py_None); resultobj = Py_None;
22854     return resultobj;
22855     fail:
22856     return NULL;
22857 }
22858
22859
22860 static PyObject *_wrap_PageSetupDialogData_SetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22861     PyObject *resultobj;
22862     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22863     wxPoint *arg2 = 0 ;
22864     wxPoint temp2 ;
22865     PyObject * obj0 = 0 ;
22866     PyObject * obj1 = 0 ;
22867     char *kwnames[] = {
22868         (char *) "self",(char *) "pt", NULL
22869     };
22870
22871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22873     if (SWIG_arg_fail(1)) SWIG_fail;
22874     {
22875         arg2 = &temp2;
22876         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22877     }
22878     {
22879         PyThreadState* __tstate = wxPyBeginAllowThreads();
22880         (arg1)->SetMinMarginBottomRight((wxPoint const &)*arg2);
22881
22882         wxPyEndAllowThreads(__tstate);
22883         if (PyErr_Occurred()) SWIG_fail;
22884     }
22885     Py_INCREF(Py_None); resultobj = Py_None;
22886     return resultobj;
22887     fail:
22888     return NULL;
22889 }
22890
22891
22892 static PyObject *_wrap_PageSetupDialogData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22893     PyObject *resultobj;
22894     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22895     wxPaperSize arg2 ;
22896     PyObject * obj0 = 0 ;
22897     PyObject * obj1 = 0 ;
22898     char *kwnames[] = {
22899         (char *) "self",(char *) "id", NULL
22900     };
22901
22902     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
22903     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22904     if (SWIG_arg_fail(1)) SWIG_fail;
22905     {
22906         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
22907         if (SWIG_arg_fail(2)) SWIG_fail;
22908     }
22909     {
22910         PyThreadState* __tstate = wxPyBeginAllowThreads();
22911         (arg1)->SetPaperId((wxPaperSize )arg2);
22912
22913         wxPyEndAllowThreads(__tstate);
22914         if (PyErr_Occurred()) SWIG_fail;
22915     }
22916     Py_INCREF(Py_None); resultobj = Py_None;
22917     return resultobj;
22918     fail:
22919     return NULL;
22920 }
22921
22922
22923 static PyObject *_wrap_PageSetupDialogData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22924     PyObject *resultobj;
22925     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22926     wxSize *arg2 = 0 ;
22927     wxSize temp2 ;
22928     PyObject * obj0 = 0 ;
22929     PyObject * obj1 = 0 ;
22930     char *kwnames[] = {
22931         (char *) "self",(char *) "size", NULL
22932     };
22933
22934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
22935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22936     if (SWIG_arg_fail(1)) SWIG_fail;
22937     {
22938         arg2 = &temp2;
22939         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
22940     }
22941     {
22942         PyThreadState* __tstate = wxPyBeginAllowThreads();
22943         (arg1)->SetPaperSize((wxSize const &)*arg2);
22944
22945         wxPyEndAllowThreads(__tstate);
22946         if (PyErr_Occurred()) SWIG_fail;
22947     }
22948     Py_INCREF(Py_None); resultobj = Py_None;
22949     return resultobj;
22950     fail:
22951     return NULL;
22952 }
22953
22954
22955 static PyObject *_wrap_PageSetupDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22956     PyObject *resultobj;
22957     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22958     wxPrintData *arg2 = 0 ;
22959     PyObject * obj0 = 0 ;
22960     PyObject * obj1 = 0 ;
22961     char *kwnames[] = {
22962         (char *) "self",(char *) "printData", NULL
22963     };
22964
22965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
22966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22967     if (SWIG_arg_fail(1)) SWIG_fail;
22968     {
22969         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22970         if (SWIG_arg_fail(2)) SWIG_fail;
22971         if (arg2 == NULL) {
22972             SWIG_null_ref("wxPrintData");
22973         }
22974         if (SWIG_arg_fail(2)) SWIG_fail;
22975     }
22976     {
22977         PyThreadState* __tstate = wxPyBeginAllowThreads();
22978         (arg1)->SetPrintData((wxPrintData const &)*arg2);
22979
22980         wxPyEndAllowThreads(__tstate);
22981         if (PyErr_Occurred()) SWIG_fail;
22982     }
22983     Py_INCREF(Py_None); resultobj = Py_None;
22984     return resultobj;
22985     fail:
22986     return NULL;
22987 }
22988
22989
22990 static PyObject *_wrap_PageSetupDialogData_CalculateIdFromPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22991     PyObject *resultobj;
22992     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22993     PyObject * obj0 = 0 ;
22994     char *kwnames[] = {
22995         (char *) "self", NULL
22996     };
22997
22998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculateIdFromPaperSize",kwnames,&obj0)) goto fail;
22999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
23000     if (SWIG_arg_fail(1)) SWIG_fail;
23001     {
23002         PyThreadState* __tstate = wxPyBeginAllowThreads();
23003         (arg1)->CalculateIdFromPaperSize();
23004
23005         wxPyEndAllowThreads(__tstate);
23006         if (PyErr_Occurred()) SWIG_fail;
23007     }
23008     Py_INCREF(Py_None); resultobj = Py_None;
23009     return resultobj;
23010     fail:
23011     return NULL;
23012 }
23013
23014
23015 static PyObject *_wrap_PageSetupDialogData_CalculatePaperSizeFromId(PyObject *, PyObject *args, PyObject *kwargs) {
23016     PyObject *resultobj;
23017     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
23018     PyObject * obj0 = 0 ;
23019     char *kwnames[] = {
23020         (char *) "self", NULL
23021     };
23022
23023     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculatePaperSizeFromId",kwnames,&obj0)) goto fail;
23024     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
23025     if (SWIG_arg_fail(1)) SWIG_fail;
23026     {
23027         PyThreadState* __tstate = wxPyBeginAllowThreads();
23028         (arg1)->CalculatePaperSizeFromId();
23029
23030         wxPyEndAllowThreads(__tstate);
23031         if (PyErr_Occurred()) SWIG_fail;
23032     }
23033     Py_INCREF(Py_None); resultobj = Py_None;
23034     return resultobj;
23035     fail:
23036     return NULL;
23037 }
23038
23039
23040 static PyObject * PageSetupDialogData_swigregister(PyObject *, PyObject *args) {
23041     PyObject *obj;
23042     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23043     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialogData, obj);
23044     Py_INCREF(obj);
23045     return Py_BuildValue((char *)"");
23046 }
23047 static PyObject *_wrap_new_PageSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23048     PyObject *resultobj;
23049     wxWindow *arg1 = (wxWindow *) 0 ;
23050     wxPageSetupDialogData *arg2 = (wxPageSetupDialogData *) NULL ;
23051     wxPageSetupDialog *result;
23052     PyObject * obj0 = 0 ;
23053     PyObject * obj1 = 0 ;
23054     char *kwnames[] = {
23055         (char *) "parent",(char *) "data", NULL
23056     };
23057
23058     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PageSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23059     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23060     if (SWIG_arg_fail(1)) SWIG_fail;
23061     if (obj1) {
23062         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
23063         if (SWIG_arg_fail(2)) SWIG_fail;
23064     }
23065     {
23066         if (!wxPyCheckForApp()) SWIG_fail;
23067         PyThreadState* __tstate = wxPyBeginAllowThreads();
23068         result = (wxPageSetupDialog *)new wxPageSetupDialog(arg1,arg2);
23069
23070         wxPyEndAllowThreads(__tstate);
23071         if (PyErr_Occurred()) SWIG_fail;
23072     }
23073     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialog, 1);
23074     return resultobj;
23075     fail:
23076     return NULL;
23077 }
23078
23079
23080 static PyObject *_wrap_PageSetupDialog_GetPageSetupData(PyObject *, PyObject *args, PyObject *kwargs) {
23081     PyObject *resultobj;
23082     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23083     wxPageSetupDialogData *result;
23084     PyObject * obj0 = 0 ;
23085     char *kwnames[] = {
23086         (char *) "self", NULL
23087     };
23088
23089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupData",kwnames,&obj0)) goto fail;
23090     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23091     if (SWIG_arg_fail(1)) SWIG_fail;
23092     {
23093         PyThreadState* __tstate = wxPyBeginAllowThreads();
23094         {
23095             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupData();
23096             result = (wxPageSetupDialogData *) &_result_ref;
23097         }
23098
23099         wxPyEndAllowThreads(__tstate);
23100         if (PyErr_Occurred()) SWIG_fail;
23101     }
23102     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
23103     return resultobj;
23104     fail:
23105     return NULL;
23106 }
23107
23108
23109 static PyObject *_wrap_PageSetupDialog_GetPageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23110     PyObject *resultobj;
23111     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23112     wxPageSetupDialogData *result;
23113     PyObject * obj0 = 0 ;
23114     char *kwnames[] = {
23115         (char *) "self", NULL
23116     };
23117
23118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupDialogData",kwnames,&obj0)) goto fail;
23119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23120     if (SWIG_arg_fail(1)) SWIG_fail;
23121     {
23122         PyThreadState* __tstate = wxPyBeginAllowThreads();
23123         {
23124             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupDialogData();
23125             result = (wxPageSetupDialogData *) &_result_ref;
23126         }
23127
23128         wxPyEndAllowThreads(__tstate);
23129         if (PyErr_Occurred()) SWIG_fail;
23130     }
23131     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
23132     return resultobj;
23133     fail:
23134     return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_PageSetupDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
23139     PyObject *resultobj;
23140     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23141     int result;
23142     PyObject * obj0 = 0 ;
23143     char *kwnames[] = {
23144         (char *) "self", NULL
23145     };
23146
23147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_ShowModal",kwnames,&obj0)) goto fail;
23148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23149     if (SWIG_arg_fail(1)) SWIG_fail;
23150     {
23151         PyThreadState* __tstate = wxPyBeginAllowThreads();
23152         result = (int)(arg1)->ShowModal();
23153
23154         wxPyEndAllowThreads(__tstate);
23155         if (PyErr_Occurred()) SWIG_fail;
23156     }
23157     {
23158         resultobj = SWIG_From_int((int)(result));
23159     }
23160     return resultobj;
23161     fail:
23162     return NULL;
23163 }
23164
23165
23166 static PyObject * PageSetupDialog_swigregister(PyObject *, PyObject *args) {
23167     PyObject *obj;
23168     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23169     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialog, obj);
23170     Py_INCREF(obj);
23171     return Py_BuildValue((char *)"");
23172 }
23173 static PyObject *_wrap_new_PrintDialogData__SWIG_0(PyObject *, PyObject *args) {
23174     PyObject *resultobj;
23175     wxPrintDialogData *result;
23176
23177     if(!PyArg_ParseTuple(args,(char *)":new_PrintDialogData")) goto fail;
23178     {
23179         PyThreadState* __tstate = wxPyBeginAllowThreads();
23180         result = (wxPrintDialogData *)new wxPrintDialogData();
23181
23182         wxPyEndAllowThreads(__tstate);
23183         if (PyErr_Occurred()) SWIG_fail;
23184     }
23185     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23186     return resultobj;
23187     fail:
23188     return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_new_PrintDialogData__SWIG_1(PyObject *, PyObject *args) {
23193     PyObject *resultobj;
23194     wxPrintData *arg1 = 0 ;
23195     wxPrintDialogData *result;
23196     PyObject * obj0 = 0 ;
23197
23198     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23199     {
23200         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
23201         if (SWIG_arg_fail(1)) SWIG_fail;
23202         if (arg1 == NULL) {
23203             SWIG_null_ref("wxPrintData");
23204         }
23205         if (SWIG_arg_fail(1)) SWIG_fail;
23206     }
23207     {
23208         PyThreadState* __tstate = wxPyBeginAllowThreads();
23209         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintData const &)*arg1);
23210
23211         wxPyEndAllowThreads(__tstate);
23212         if (PyErr_Occurred()) SWIG_fail;
23213     }
23214     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23215     return resultobj;
23216     fail:
23217     return NULL;
23218 }
23219
23220
23221 static PyObject *_wrap_new_PrintDialogData__SWIG_2(PyObject *, PyObject *args) {
23222     PyObject *resultobj;
23223     wxPrintDialogData *arg1 = 0 ;
23224     wxPrintDialogData *result;
23225     PyObject * obj0 = 0 ;
23226
23227     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23228     {
23229         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23230         if (SWIG_arg_fail(1)) SWIG_fail;
23231         if (arg1 == NULL) {
23232             SWIG_null_ref("wxPrintDialogData");
23233         }
23234         if (SWIG_arg_fail(1)) SWIG_fail;
23235     }
23236     {
23237         PyThreadState* __tstate = wxPyBeginAllowThreads();
23238         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintDialogData const &)*arg1);
23239
23240         wxPyEndAllowThreads(__tstate);
23241         if (PyErr_Occurred()) SWIG_fail;
23242     }
23243     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23244     return resultobj;
23245     fail:
23246     return NULL;
23247 }
23248
23249
23250 static PyObject *_wrap_new_PrintDialogData(PyObject *self, PyObject *args) {
23251     int argc;
23252     PyObject *argv[2];
23253     int ii;
23254
23255     argc = PyObject_Length(args);
23256     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23257         argv[ii] = PyTuple_GetItem(args,ii);
23258     }
23259     if (argc == 0) {
23260         return _wrap_new_PrintDialogData__SWIG_0(self,args);
23261     }
23262     if (argc == 1) {
23263         int _v;
23264         {
23265             void *ptr = 0;
23266             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
23267                 _v = 0;
23268                 PyErr_Clear();
23269             } else {
23270                 _v = (ptr != 0);
23271             }
23272         }
23273         if (_v) {
23274             return _wrap_new_PrintDialogData__SWIG_1(self,args);
23275         }
23276     }
23277     if (argc == 1) {
23278         int _v;
23279         {
23280             void *ptr = 0;
23281             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
23282                 _v = 0;
23283                 PyErr_Clear();
23284             } else {
23285                 _v = (ptr != 0);
23286             }
23287         }
23288         if (_v) {
23289             return _wrap_new_PrintDialogData__SWIG_2(self,args);
23290         }
23291     }
23292
23293     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintDialogData'");
23294     return NULL;
23295 }
23296
23297
23298 static PyObject *_wrap_delete_PrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23299     PyObject *resultobj;
23300     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23301     PyObject * obj0 = 0 ;
23302     char *kwnames[] = {
23303         (char *) "self", NULL
23304     };
23305
23306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintDialogData",kwnames,&obj0)) goto fail;
23307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23308     if (SWIG_arg_fail(1)) SWIG_fail;
23309     {
23310         PyThreadState* __tstate = wxPyBeginAllowThreads();
23311         delete arg1;
23312
23313         wxPyEndAllowThreads(__tstate);
23314         if (PyErr_Occurred()) SWIG_fail;
23315     }
23316     Py_INCREF(Py_None); resultobj = Py_None;
23317     return resultobj;
23318     fail:
23319     return NULL;
23320 }
23321
23322
23323 static PyObject *_wrap_PrintDialogData_GetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23324     PyObject *resultobj;
23325     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23326     int result;
23327     PyObject * obj0 = 0 ;
23328     char *kwnames[] = {
23329         (char *) "self", NULL
23330     };
23331
23332     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetFromPage",kwnames,&obj0)) goto fail;
23333     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23334     if (SWIG_arg_fail(1)) SWIG_fail;
23335     {
23336         PyThreadState* __tstate = wxPyBeginAllowThreads();
23337         result = (int)((wxPrintDialogData const *)arg1)->GetFromPage();
23338
23339         wxPyEndAllowThreads(__tstate);
23340         if (PyErr_Occurred()) SWIG_fail;
23341     }
23342     {
23343         resultobj = SWIG_From_int((int)(result));
23344     }
23345     return resultobj;
23346     fail:
23347     return NULL;
23348 }
23349
23350
23351 static PyObject *_wrap_PrintDialogData_GetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23352     PyObject *resultobj;
23353     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23354     int result;
23355     PyObject * obj0 = 0 ;
23356     char *kwnames[] = {
23357         (char *) "self", NULL
23358     };
23359
23360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetToPage",kwnames,&obj0)) goto fail;
23361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23362     if (SWIG_arg_fail(1)) SWIG_fail;
23363     {
23364         PyThreadState* __tstate = wxPyBeginAllowThreads();
23365         result = (int)((wxPrintDialogData const *)arg1)->GetToPage();
23366
23367         wxPyEndAllowThreads(__tstate);
23368         if (PyErr_Occurred()) SWIG_fail;
23369     }
23370     {
23371         resultobj = SWIG_From_int((int)(result));
23372     }
23373     return resultobj;
23374     fail:
23375     return NULL;
23376 }
23377
23378
23379 static PyObject *_wrap_PrintDialogData_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23380     PyObject *resultobj;
23381     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23382     int result;
23383     PyObject * obj0 = 0 ;
23384     char *kwnames[] = {
23385         (char *) "self", NULL
23386     };
23387
23388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMinPage",kwnames,&obj0)) goto fail;
23389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23390     if (SWIG_arg_fail(1)) SWIG_fail;
23391     {
23392         PyThreadState* __tstate = wxPyBeginAllowThreads();
23393         result = (int)((wxPrintDialogData const *)arg1)->GetMinPage();
23394
23395         wxPyEndAllowThreads(__tstate);
23396         if (PyErr_Occurred()) SWIG_fail;
23397     }
23398     {
23399         resultobj = SWIG_From_int((int)(result));
23400     }
23401     return resultobj;
23402     fail:
23403     return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_PrintDialogData_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23408     PyObject *resultobj;
23409     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23410     int result;
23411     PyObject * obj0 = 0 ;
23412     char *kwnames[] = {
23413         (char *) "self", NULL
23414     };
23415
23416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMaxPage",kwnames,&obj0)) goto fail;
23417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23418     if (SWIG_arg_fail(1)) SWIG_fail;
23419     {
23420         PyThreadState* __tstate = wxPyBeginAllowThreads();
23421         result = (int)((wxPrintDialogData const *)arg1)->GetMaxPage();
23422
23423         wxPyEndAllowThreads(__tstate);
23424         if (PyErr_Occurred()) SWIG_fail;
23425     }
23426     {
23427         resultobj = SWIG_From_int((int)(result));
23428     }
23429     return resultobj;
23430     fail:
23431     return NULL;
23432 }
23433
23434
23435 static PyObject *_wrap_PrintDialogData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23436     PyObject *resultobj;
23437     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23438     int result;
23439     PyObject * obj0 = 0 ;
23440     char *kwnames[] = {
23441         (char *) "self", NULL
23442     };
23443
23444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetNoCopies",kwnames,&obj0)) goto fail;
23445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23446     if (SWIG_arg_fail(1)) SWIG_fail;
23447     {
23448         PyThreadState* __tstate = wxPyBeginAllowThreads();
23449         result = (int)((wxPrintDialogData const *)arg1)->GetNoCopies();
23450
23451         wxPyEndAllowThreads(__tstate);
23452         if (PyErr_Occurred()) SWIG_fail;
23453     }
23454     {
23455         resultobj = SWIG_From_int((int)(result));
23456     }
23457     return resultobj;
23458     fail:
23459     return NULL;
23460 }
23461
23462
23463 static PyObject *_wrap_PrintDialogData_GetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23464     PyObject *resultobj;
23465     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23466     bool result;
23467     PyObject * obj0 = 0 ;
23468     char *kwnames[] = {
23469         (char *) "self", NULL
23470     };
23471
23472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetAllPages",kwnames,&obj0)) goto fail;
23473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23474     if (SWIG_arg_fail(1)) SWIG_fail;
23475     {
23476         PyThreadState* __tstate = wxPyBeginAllowThreads();
23477         result = (bool)((wxPrintDialogData const *)arg1)->GetAllPages();
23478
23479         wxPyEndAllowThreads(__tstate);
23480         if (PyErr_Occurred()) SWIG_fail;
23481     }
23482     {
23483         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23484     }
23485     return resultobj;
23486     fail:
23487     return NULL;
23488 }
23489
23490
23491 static PyObject *_wrap_PrintDialogData_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23492     PyObject *resultobj;
23493     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23494     bool result;
23495     PyObject * obj0 = 0 ;
23496     char *kwnames[] = {
23497         (char *) "self", NULL
23498     };
23499
23500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSelection",kwnames,&obj0)) goto fail;
23501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23502     if (SWIG_arg_fail(1)) SWIG_fail;
23503     {
23504         PyThreadState* __tstate = wxPyBeginAllowThreads();
23505         result = (bool)((wxPrintDialogData const *)arg1)->GetSelection();
23506
23507         wxPyEndAllowThreads(__tstate);
23508         if (PyErr_Occurred()) SWIG_fail;
23509     }
23510     {
23511         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23512     }
23513     return resultobj;
23514     fail:
23515     return NULL;
23516 }
23517
23518
23519 static PyObject *_wrap_PrintDialogData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23520     PyObject *resultobj;
23521     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23522     bool result;
23523     PyObject * obj0 = 0 ;
23524     char *kwnames[] = {
23525         (char *) "self", NULL
23526     };
23527
23528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetCollate",kwnames,&obj0)) goto fail;
23529     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23530     if (SWIG_arg_fail(1)) SWIG_fail;
23531     {
23532         PyThreadState* __tstate = wxPyBeginAllowThreads();
23533         result = (bool)((wxPrintDialogData const *)arg1)->GetCollate();
23534
23535         wxPyEndAllowThreads(__tstate);
23536         if (PyErr_Occurred()) SWIG_fail;
23537     }
23538     {
23539         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23540     }
23541     return resultobj;
23542     fail:
23543     return NULL;
23544 }
23545
23546
23547 static PyObject *_wrap_PrintDialogData_GetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23548     PyObject *resultobj;
23549     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23550     bool result;
23551     PyObject * obj0 = 0 ;
23552     char *kwnames[] = {
23553         (char *) "self", NULL
23554     };
23555
23556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintToFile",kwnames,&obj0)) goto fail;
23557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23558     if (SWIG_arg_fail(1)) SWIG_fail;
23559     {
23560         PyThreadState* __tstate = wxPyBeginAllowThreads();
23561         result = (bool)((wxPrintDialogData const *)arg1)->GetPrintToFile();
23562
23563         wxPyEndAllowThreads(__tstate);
23564         if (PyErr_Occurred()) SWIG_fail;
23565     }
23566     {
23567         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23568     }
23569     return resultobj;
23570     fail:
23571     return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_PrintDialogData_GetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23576     PyObject *resultobj;
23577     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23578     bool result;
23579     PyObject * obj0 = 0 ;
23580     char *kwnames[] = {
23581         (char *) "self", NULL
23582     };
23583
23584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSetupDialog",kwnames,&obj0)) goto fail;
23585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23586     if (SWIG_arg_fail(1)) SWIG_fail;
23587     {
23588         PyThreadState* __tstate = wxPyBeginAllowThreads();
23589         result = (bool)((wxPrintDialogData const *)arg1)->GetSetupDialog();
23590
23591         wxPyEndAllowThreads(__tstate);
23592         if (PyErr_Occurred()) SWIG_fail;
23593     }
23594     {
23595         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23596     }
23597     return resultobj;
23598     fail:
23599     return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PrintDialogData_SetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23604     PyObject *resultobj;
23605     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23606     bool arg2 ;
23607     PyObject * obj0 = 0 ;
23608     PyObject * obj1 = 0 ;
23609     char *kwnames[] = {
23610         (char *) "self",(char *) "flag", NULL
23611     };
23612
23613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23615     if (SWIG_arg_fail(1)) SWIG_fail;
23616     {
23617         arg2 = (bool)(SWIG_As_bool(obj1));
23618         if (SWIG_arg_fail(2)) SWIG_fail;
23619     }
23620     {
23621         PyThreadState* __tstate = wxPyBeginAllowThreads();
23622         (arg1)->SetSetupDialog(arg2);
23623
23624         wxPyEndAllowThreads(__tstate);
23625         if (PyErr_Occurred()) SWIG_fail;
23626     }
23627     Py_INCREF(Py_None); resultobj = Py_None;
23628     return resultobj;
23629     fail:
23630     return NULL;
23631 }
23632
23633
23634 static PyObject *_wrap_PrintDialogData_SetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23635     PyObject *resultobj;
23636     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23637     int arg2 ;
23638     PyObject * obj0 = 0 ;
23639     PyObject * obj1 = 0 ;
23640     char *kwnames[] = {
23641         (char *) "self",(char *) "v", NULL
23642     };
23643
23644     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetFromPage",kwnames,&obj0,&obj1)) goto fail;
23645     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23646     if (SWIG_arg_fail(1)) SWIG_fail;
23647     {
23648         arg2 = (int)(SWIG_As_int(obj1));
23649         if (SWIG_arg_fail(2)) SWIG_fail;
23650     }
23651     {
23652         PyThreadState* __tstate = wxPyBeginAllowThreads();
23653         (arg1)->SetFromPage(arg2);
23654
23655         wxPyEndAllowThreads(__tstate);
23656         if (PyErr_Occurred()) SWIG_fail;
23657     }
23658     Py_INCREF(Py_None); resultobj = Py_None;
23659     return resultobj;
23660     fail:
23661     return NULL;
23662 }
23663
23664
23665 static PyObject *_wrap_PrintDialogData_SetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23666     PyObject *resultobj;
23667     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23668     int arg2 ;
23669     PyObject * obj0 = 0 ;
23670     PyObject * obj1 = 0 ;
23671     char *kwnames[] = {
23672         (char *) "self",(char *) "v", NULL
23673     };
23674
23675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetToPage",kwnames,&obj0,&obj1)) goto fail;
23676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23677     if (SWIG_arg_fail(1)) SWIG_fail;
23678     {
23679         arg2 = (int)(SWIG_As_int(obj1));
23680         if (SWIG_arg_fail(2)) SWIG_fail;
23681     }
23682     {
23683         PyThreadState* __tstate = wxPyBeginAllowThreads();
23684         (arg1)->SetToPage(arg2);
23685
23686         wxPyEndAllowThreads(__tstate);
23687         if (PyErr_Occurred()) SWIG_fail;
23688     }
23689     Py_INCREF(Py_None); resultobj = Py_None;
23690     return resultobj;
23691     fail:
23692     return NULL;
23693 }
23694
23695
23696 static PyObject *_wrap_PrintDialogData_SetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23697     PyObject *resultobj;
23698     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23699     int arg2 ;
23700     PyObject * obj0 = 0 ;
23701     PyObject * obj1 = 0 ;
23702     char *kwnames[] = {
23703         (char *) "self",(char *) "v", NULL
23704     };
23705
23706     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMinPage",kwnames,&obj0,&obj1)) goto fail;
23707     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23708     if (SWIG_arg_fail(1)) SWIG_fail;
23709     {
23710         arg2 = (int)(SWIG_As_int(obj1));
23711         if (SWIG_arg_fail(2)) SWIG_fail;
23712     }
23713     {
23714         PyThreadState* __tstate = wxPyBeginAllowThreads();
23715         (arg1)->SetMinPage(arg2);
23716
23717         wxPyEndAllowThreads(__tstate);
23718         if (PyErr_Occurred()) SWIG_fail;
23719     }
23720     Py_INCREF(Py_None); resultobj = Py_None;
23721     return resultobj;
23722     fail:
23723     return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_PrintDialogData_SetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23728     PyObject *resultobj;
23729     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23730     int arg2 ;
23731     PyObject * obj0 = 0 ;
23732     PyObject * obj1 = 0 ;
23733     char *kwnames[] = {
23734         (char *) "self",(char *) "v", NULL
23735     };
23736
23737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMaxPage",kwnames,&obj0,&obj1)) goto fail;
23738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23739     if (SWIG_arg_fail(1)) SWIG_fail;
23740     {
23741         arg2 = (int)(SWIG_As_int(obj1));
23742         if (SWIG_arg_fail(2)) SWIG_fail;
23743     }
23744     {
23745         PyThreadState* __tstate = wxPyBeginAllowThreads();
23746         (arg1)->SetMaxPage(arg2);
23747
23748         wxPyEndAllowThreads(__tstate);
23749         if (PyErr_Occurred()) SWIG_fail;
23750     }
23751     Py_INCREF(Py_None); resultobj = Py_None;
23752     return resultobj;
23753     fail:
23754     return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_PrintDialogData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23759     PyObject *resultobj;
23760     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23761     int arg2 ;
23762     PyObject * obj0 = 0 ;
23763     PyObject * obj1 = 0 ;
23764     char *kwnames[] = {
23765         (char *) "self",(char *) "v", NULL
23766     };
23767
23768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
23769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23770     if (SWIG_arg_fail(1)) SWIG_fail;
23771     {
23772         arg2 = (int)(SWIG_As_int(obj1));
23773         if (SWIG_arg_fail(2)) SWIG_fail;
23774     }
23775     {
23776         PyThreadState* __tstate = wxPyBeginAllowThreads();
23777         (arg1)->SetNoCopies(arg2);
23778
23779         wxPyEndAllowThreads(__tstate);
23780         if (PyErr_Occurred()) SWIG_fail;
23781     }
23782     Py_INCREF(Py_None); resultobj = Py_None;
23783     return resultobj;
23784     fail:
23785     return NULL;
23786 }
23787
23788
23789 static PyObject *_wrap_PrintDialogData_SetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23790     PyObject *resultobj;
23791     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23792     bool arg2 ;
23793     PyObject * obj0 = 0 ;
23794     PyObject * obj1 = 0 ;
23795     char *kwnames[] = {
23796         (char *) "self",(char *) "flag", NULL
23797     };
23798
23799     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetAllPages",kwnames,&obj0,&obj1)) goto fail;
23800     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23801     if (SWIG_arg_fail(1)) SWIG_fail;
23802     {
23803         arg2 = (bool)(SWIG_As_bool(obj1));
23804         if (SWIG_arg_fail(2)) SWIG_fail;
23805     }
23806     {
23807         PyThreadState* __tstate = wxPyBeginAllowThreads();
23808         (arg1)->SetAllPages(arg2);
23809
23810         wxPyEndAllowThreads(__tstate);
23811         if (PyErr_Occurred()) SWIG_fail;
23812     }
23813     Py_INCREF(Py_None); resultobj = Py_None;
23814     return resultobj;
23815     fail:
23816     return NULL;
23817 }
23818
23819
23820 static PyObject *_wrap_PrintDialogData_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23821     PyObject *resultobj;
23822     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23823     bool arg2 ;
23824     PyObject * obj0 = 0 ;
23825     PyObject * obj1 = 0 ;
23826     char *kwnames[] = {
23827         (char *) "self",(char *) "flag", NULL
23828     };
23829
23830     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSelection",kwnames,&obj0,&obj1)) goto fail;
23831     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23832     if (SWIG_arg_fail(1)) SWIG_fail;
23833     {
23834         arg2 = (bool)(SWIG_As_bool(obj1));
23835         if (SWIG_arg_fail(2)) SWIG_fail;
23836     }
23837     {
23838         PyThreadState* __tstate = wxPyBeginAllowThreads();
23839         (arg1)->SetSelection(arg2);
23840
23841         wxPyEndAllowThreads(__tstate);
23842         if (PyErr_Occurred()) SWIG_fail;
23843     }
23844     Py_INCREF(Py_None); resultobj = Py_None;
23845     return resultobj;
23846     fail:
23847     return NULL;
23848 }
23849
23850
23851 static PyObject *_wrap_PrintDialogData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23852     PyObject *resultobj;
23853     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23854     bool arg2 ;
23855     PyObject * obj0 = 0 ;
23856     PyObject * obj1 = 0 ;
23857     char *kwnames[] = {
23858         (char *) "self",(char *) "flag", NULL
23859     };
23860
23861     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
23862     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23863     if (SWIG_arg_fail(1)) SWIG_fail;
23864     {
23865         arg2 = (bool)(SWIG_As_bool(obj1));
23866         if (SWIG_arg_fail(2)) SWIG_fail;
23867     }
23868     {
23869         PyThreadState* __tstate = wxPyBeginAllowThreads();
23870         (arg1)->SetCollate(arg2);
23871
23872         wxPyEndAllowThreads(__tstate);
23873         if (PyErr_Occurred()) SWIG_fail;
23874     }
23875     Py_INCREF(Py_None); resultobj = Py_None;
23876     return resultobj;
23877     fail:
23878     return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_PrintDialogData_SetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23883     PyObject *resultobj;
23884     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23885     bool arg2 ;
23886     PyObject * obj0 = 0 ;
23887     PyObject * obj1 = 0 ;
23888     char *kwnames[] = {
23889         (char *) "self",(char *) "flag", NULL
23890     };
23891
23892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintToFile",kwnames,&obj0,&obj1)) goto fail;
23893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23894     if (SWIG_arg_fail(1)) SWIG_fail;
23895     {
23896         arg2 = (bool)(SWIG_As_bool(obj1));
23897         if (SWIG_arg_fail(2)) SWIG_fail;
23898     }
23899     {
23900         PyThreadState* __tstate = wxPyBeginAllowThreads();
23901         (arg1)->SetPrintToFile(arg2);
23902
23903         wxPyEndAllowThreads(__tstate);
23904         if (PyErr_Occurred()) SWIG_fail;
23905     }
23906     Py_INCREF(Py_None); resultobj = Py_None;
23907     return resultobj;
23908     fail:
23909     return NULL;
23910 }
23911
23912
23913 static PyObject *_wrap_PrintDialogData_EnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23914     PyObject *resultobj;
23915     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23916     bool arg2 ;
23917     PyObject * obj0 = 0 ;
23918     PyObject * obj1 = 0 ;
23919     char *kwnames[] = {
23920         (char *) "self",(char *) "flag", NULL
23921     };
23922
23923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePrintToFile",kwnames,&obj0,&obj1)) goto fail;
23924     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23925     if (SWIG_arg_fail(1)) SWIG_fail;
23926     {
23927         arg2 = (bool)(SWIG_As_bool(obj1));
23928         if (SWIG_arg_fail(2)) SWIG_fail;
23929     }
23930     {
23931         PyThreadState* __tstate = wxPyBeginAllowThreads();
23932         (arg1)->EnablePrintToFile(arg2);
23933
23934         wxPyEndAllowThreads(__tstate);
23935         if (PyErr_Occurred()) SWIG_fail;
23936     }
23937     Py_INCREF(Py_None); resultobj = Py_None;
23938     return resultobj;
23939     fail:
23940     return NULL;
23941 }
23942
23943
23944 static PyObject *_wrap_PrintDialogData_EnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23945     PyObject *resultobj;
23946     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23947     bool arg2 ;
23948     PyObject * obj0 = 0 ;
23949     PyObject * obj1 = 0 ;
23950     char *kwnames[] = {
23951         (char *) "self",(char *) "flag", NULL
23952     };
23953
23954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableSelection",kwnames,&obj0,&obj1)) goto fail;
23955     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23956     if (SWIG_arg_fail(1)) SWIG_fail;
23957     {
23958         arg2 = (bool)(SWIG_As_bool(obj1));
23959         if (SWIG_arg_fail(2)) SWIG_fail;
23960     }
23961     {
23962         PyThreadState* __tstate = wxPyBeginAllowThreads();
23963         (arg1)->EnableSelection(arg2);
23964
23965         wxPyEndAllowThreads(__tstate);
23966         if (PyErr_Occurred()) SWIG_fail;
23967     }
23968     Py_INCREF(Py_None); resultobj = Py_None;
23969     return resultobj;
23970     fail:
23971     return NULL;
23972 }
23973
23974
23975 static PyObject *_wrap_PrintDialogData_EnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23976     PyObject *resultobj;
23977     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23978     bool arg2 ;
23979     PyObject * obj0 = 0 ;
23980     PyObject * obj1 = 0 ;
23981     char *kwnames[] = {
23982         (char *) "self",(char *) "flag", NULL
23983     };
23984
23985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePageNumbers",kwnames,&obj0,&obj1)) goto fail;
23986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23987     if (SWIG_arg_fail(1)) SWIG_fail;
23988     {
23989         arg2 = (bool)(SWIG_As_bool(obj1));
23990         if (SWIG_arg_fail(2)) SWIG_fail;
23991     }
23992     {
23993         PyThreadState* __tstate = wxPyBeginAllowThreads();
23994         (arg1)->EnablePageNumbers(arg2);
23995
23996         wxPyEndAllowThreads(__tstate);
23997         if (PyErr_Occurred()) SWIG_fail;
23998     }
23999     Py_INCREF(Py_None); resultobj = Py_None;
24000     return resultobj;
24001     fail:
24002     return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_PrintDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
24007     PyObject *resultobj;
24008     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24009     bool arg2 ;
24010     PyObject * obj0 = 0 ;
24011     PyObject * obj1 = 0 ;
24012     char *kwnames[] = {
24013         (char *) "self",(char *) "flag", NULL
24014     };
24015
24016     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
24017     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24018     if (SWIG_arg_fail(1)) SWIG_fail;
24019     {
24020         arg2 = (bool)(SWIG_As_bool(obj1));
24021         if (SWIG_arg_fail(2)) SWIG_fail;
24022     }
24023     {
24024         PyThreadState* __tstate = wxPyBeginAllowThreads();
24025         (arg1)->EnableHelp(arg2);
24026
24027         wxPyEndAllowThreads(__tstate);
24028         if (PyErr_Occurred()) SWIG_fail;
24029     }
24030     Py_INCREF(Py_None); resultobj = Py_None;
24031     return resultobj;
24032     fail:
24033     return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_PrintDialogData_GetEnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
24038     PyObject *resultobj;
24039     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24040     bool result;
24041     PyObject * obj0 = 0 ;
24042     char *kwnames[] = {
24043         (char *) "self", NULL
24044     };
24045
24046     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePrintToFile",kwnames,&obj0)) goto fail;
24047     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24048     if (SWIG_arg_fail(1)) SWIG_fail;
24049     {
24050         PyThreadState* __tstate = wxPyBeginAllowThreads();
24051         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePrintToFile();
24052
24053         wxPyEndAllowThreads(__tstate);
24054         if (PyErr_Occurred()) SWIG_fail;
24055     }
24056     {
24057         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24058     }
24059     return resultobj;
24060     fail:
24061     return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_PrintDialogData_GetEnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
24066     PyObject *resultobj;
24067     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24068     bool result;
24069     PyObject * obj0 = 0 ;
24070     char *kwnames[] = {
24071         (char *) "self", NULL
24072     };
24073
24074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableSelection",kwnames,&obj0)) goto fail;
24075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24076     if (SWIG_arg_fail(1)) SWIG_fail;
24077     {
24078         PyThreadState* __tstate = wxPyBeginAllowThreads();
24079         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableSelection();
24080
24081         wxPyEndAllowThreads(__tstate);
24082         if (PyErr_Occurred()) SWIG_fail;
24083     }
24084     {
24085         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24086     }
24087     return resultobj;
24088     fail:
24089     return NULL;
24090 }
24091
24092
24093 static PyObject *_wrap_PrintDialogData_GetEnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
24094     PyObject *resultobj;
24095     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24096     bool result;
24097     PyObject * obj0 = 0 ;
24098     char *kwnames[] = {
24099         (char *) "self", NULL
24100     };
24101
24102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePageNumbers",kwnames,&obj0)) goto fail;
24103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24104     if (SWIG_arg_fail(1)) SWIG_fail;
24105     {
24106         PyThreadState* __tstate = wxPyBeginAllowThreads();
24107         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePageNumbers();
24108
24109         wxPyEndAllowThreads(__tstate);
24110         if (PyErr_Occurred()) SWIG_fail;
24111     }
24112     {
24113         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24114     }
24115     return resultobj;
24116     fail:
24117     return NULL;
24118 }
24119
24120
24121 static PyObject *_wrap_PrintDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
24122     PyObject *resultobj;
24123     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24124     bool result;
24125     PyObject * obj0 = 0 ;
24126     char *kwnames[] = {
24127         (char *) "self", NULL
24128     };
24129
24130     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
24131     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24132     if (SWIG_arg_fail(1)) SWIG_fail;
24133     {
24134         PyThreadState* __tstate = wxPyBeginAllowThreads();
24135         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableHelp();
24136
24137         wxPyEndAllowThreads(__tstate);
24138         if (PyErr_Occurred()) SWIG_fail;
24139     }
24140     {
24141         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24142     }
24143     return resultobj;
24144     fail:
24145     return NULL;
24146 }
24147
24148
24149 static PyObject *_wrap_PrintDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24150     PyObject *resultobj;
24151     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24152     bool result;
24153     PyObject * obj0 = 0 ;
24154     char *kwnames[] = {
24155         (char *) "self", NULL
24156     };
24157
24158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_Ok",kwnames,&obj0)) goto fail;
24159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24160     if (SWIG_arg_fail(1)) SWIG_fail;
24161     {
24162         PyThreadState* __tstate = wxPyBeginAllowThreads();
24163         result = (bool)((wxPrintDialogData const *)arg1)->Ok();
24164
24165         wxPyEndAllowThreads(__tstate);
24166         if (PyErr_Occurred()) SWIG_fail;
24167     }
24168     {
24169         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24170     }
24171     return resultobj;
24172     fail:
24173     return NULL;
24174 }
24175
24176
24177 static PyObject *_wrap_PrintDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24178     PyObject *resultobj;
24179     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24180     wxPrintData *result;
24181     PyObject * obj0 = 0 ;
24182     char *kwnames[] = {
24183         (char *) "self", NULL
24184     };
24185
24186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintData",kwnames,&obj0)) goto fail;
24187     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24188     if (SWIG_arg_fail(1)) SWIG_fail;
24189     {
24190         PyThreadState* __tstate = wxPyBeginAllowThreads();
24191         {
24192             wxPrintData &_result_ref = (arg1)->GetPrintData();
24193             result = (wxPrintData *) &_result_ref;
24194         }
24195
24196         wxPyEndAllowThreads(__tstate);
24197         if (PyErr_Occurred()) SWIG_fail;
24198     }
24199     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24200     return resultobj;
24201     fail:
24202     return NULL;
24203 }
24204
24205
24206 static PyObject *_wrap_PrintDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24207     PyObject *resultobj;
24208     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24209     wxPrintData *arg2 = 0 ;
24210     PyObject * obj0 = 0 ;
24211     PyObject * obj1 = 0 ;
24212     char *kwnames[] = {
24213         (char *) "self",(char *) "printData", NULL
24214     };
24215
24216     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
24217     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24218     if (SWIG_arg_fail(1)) SWIG_fail;
24219     {
24220         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
24221         if (SWIG_arg_fail(2)) SWIG_fail;
24222         if (arg2 == NULL) {
24223             SWIG_null_ref("wxPrintData");
24224         }
24225         if (SWIG_arg_fail(2)) SWIG_fail;
24226     }
24227     {
24228         PyThreadState* __tstate = wxPyBeginAllowThreads();
24229         (arg1)->SetPrintData((wxPrintData const &)*arg2);
24230
24231         wxPyEndAllowThreads(__tstate);
24232         if (PyErr_Occurred()) SWIG_fail;
24233     }
24234     Py_INCREF(Py_None); resultobj = Py_None;
24235     return resultobj;
24236     fail:
24237     return NULL;
24238 }
24239
24240
24241 static PyObject * PrintDialogData_swigregister(PyObject *, PyObject *args) {
24242     PyObject *obj;
24243     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24244     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialogData, obj);
24245     Py_INCREF(obj);
24246     return Py_BuildValue((char *)"");
24247 }
24248 static PyObject *_wrap_new_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24249     PyObject *resultobj;
24250     wxWindow *arg1 = (wxWindow *) 0 ;
24251     wxPrintDialogData *arg2 = (wxPrintDialogData *) NULL ;
24252     wxPrintDialog *result;
24253     PyObject * obj0 = 0 ;
24254     PyObject * obj1 = 0 ;
24255     char *kwnames[] = {
24256         (char *) "parent",(char *) "data", NULL
24257     };
24258
24259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24260     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24261     if (SWIG_arg_fail(1)) SWIG_fail;
24262     if (obj1) {
24263         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24264         if (SWIG_arg_fail(2)) SWIG_fail;
24265     }
24266     {
24267         if (!wxPyCheckForApp()) SWIG_fail;
24268         PyThreadState* __tstate = wxPyBeginAllowThreads();
24269         result = (wxPrintDialog *)new wxPrintDialog(arg1,arg2);
24270
24271         wxPyEndAllowThreads(__tstate);
24272         if (PyErr_Occurred()) SWIG_fail;
24273     }
24274     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialog, 1);
24275     return resultobj;
24276     fail:
24277     return NULL;
24278 }
24279
24280
24281 static PyObject *_wrap_PrintDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
24282     PyObject *resultobj;
24283     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24284     int result;
24285     PyObject * obj0 = 0 ;
24286     char *kwnames[] = {
24287         (char *) "self", NULL
24288     };
24289
24290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_ShowModal",kwnames,&obj0)) goto fail;
24291     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24292     if (SWIG_arg_fail(1)) SWIG_fail;
24293     {
24294         PyThreadState* __tstate = wxPyBeginAllowThreads();
24295         result = (int)(arg1)->ShowModal();
24296
24297         wxPyEndAllowThreads(__tstate);
24298         if (PyErr_Occurred()) SWIG_fail;
24299     }
24300     {
24301         resultobj = SWIG_From_int((int)(result));
24302     }
24303     return resultobj;
24304     fail:
24305     return NULL;
24306 }
24307
24308
24309 static PyObject *_wrap_PrintDialog_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24310     PyObject *resultobj;
24311     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24312     wxPrintDialogData *result;
24313     PyObject * obj0 = 0 ;
24314     char *kwnames[] = {
24315         (char *) "self", NULL
24316     };
24317
24318     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDialogData",kwnames,&obj0)) goto fail;
24319     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24320     if (SWIG_arg_fail(1)) SWIG_fail;
24321     {
24322         PyThreadState* __tstate = wxPyBeginAllowThreads();
24323         {
24324             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
24325             result = (wxPrintDialogData *) &_result_ref;
24326         }
24327
24328         wxPyEndAllowThreads(__tstate);
24329         if (PyErr_Occurred()) SWIG_fail;
24330     }
24331     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24332     return resultobj;
24333     fail:
24334     return NULL;
24335 }
24336
24337
24338 static PyObject *_wrap_PrintDialog_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24339     PyObject *resultobj;
24340     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24341     wxPrintData *result;
24342     PyObject * obj0 = 0 ;
24343     char *kwnames[] = {
24344         (char *) "self", NULL
24345     };
24346
24347     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintData",kwnames,&obj0)) goto fail;
24348     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24349     if (SWIG_arg_fail(1)) SWIG_fail;
24350     {
24351         PyThreadState* __tstate = wxPyBeginAllowThreads();
24352         {
24353             wxPrintData &_result_ref = (arg1)->GetPrintData();
24354             result = (wxPrintData *) &_result_ref;
24355         }
24356
24357         wxPyEndAllowThreads(__tstate);
24358         if (PyErr_Occurred()) SWIG_fail;
24359     }
24360     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24361     return resultobj;
24362     fail:
24363     return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_PrintDialog_GetPrintDC(PyObject *, PyObject *args, PyObject *kwargs) {
24368     PyObject *resultobj;
24369     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24370     wxDC *result;
24371     PyObject * obj0 = 0 ;
24372     char *kwnames[] = {
24373         (char *) "self", NULL
24374     };
24375
24376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDC",kwnames,&obj0)) goto fail;
24377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24378     if (SWIG_arg_fail(1)) SWIG_fail;
24379     {
24380         PyThreadState* __tstate = wxPyBeginAllowThreads();
24381         result = (wxDC *)(arg1)->GetPrintDC();
24382
24383         wxPyEndAllowThreads(__tstate);
24384         if (PyErr_Occurred()) SWIG_fail;
24385     }
24386     {
24387         resultobj = wxPyMake_wxObject(result, 1);
24388     }
24389     return resultobj;
24390     fail:
24391     return NULL;
24392 }
24393
24394
24395 static PyObject * PrintDialog_swigregister(PyObject *, PyObject *args) {
24396     PyObject *obj;
24397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24398     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialog, obj);
24399     Py_INCREF(obj);
24400     return Py_BuildValue((char *)"");
24401 }
24402 static PyObject *_wrap_new_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24403     PyObject *resultobj;
24404     wxPrintDialogData *arg1 = (wxPrintDialogData *) NULL ;
24405     wxPrinter *result;
24406     PyObject * obj0 = 0 ;
24407     char *kwnames[] = {
24408         (char *) "data", NULL
24409     };
24410
24411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printer",kwnames,&obj0)) goto fail;
24412     if (obj0) {
24413         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24414         if (SWIG_arg_fail(1)) SWIG_fail;
24415     }
24416     {
24417         if (!wxPyCheckForApp()) SWIG_fail;
24418         PyThreadState* __tstate = wxPyBeginAllowThreads();
24419         result = (wxPrinter *)new wxPrinter(arg1);
24420
24421         wxPyEndAllowThreads(__tstate);
24422         if (PyErr_Occurred()) SWIG_fail;
24423     }
24424     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinter, 1);
24425     return resultobj;
24426     fail:
24427     return NULL;
24428 }
24429
24430
24431 static PyObject *_wrap_delete_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24432     PyObject *resultobj;
24433     wxPrinter *arg1 = (wxPrinter *) 0 ;
24434     PyObject * obj0 = 0 ;
24435     char *kwnames[] = {
24436         (char *) "self", NULL
24437     };
24438
24439     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Printer",kwnames,&obj0)) goto fail;
24440     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24441     if (SWIG_arg_fail(1)) SWIG_fail;
24442     {
24443         PyThreadState* __tstate = wxPyBeginAllowThreads();
24444         delete arg1;
24445
24446         wxPyEndAllowThreads(__tstate);
24447         if (PyErr_Occurred()) SWIG_fail;
24448     }
24449     Py_INCREF(Py_None); resultobj = Py_None;
24450     return resultobj;
24451     fail:
24452     return NULL;
24453 }
24454
24455
24456 static PyObject *_wrap_Printer_CreateAbortWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24457     PyObject *resultobj;
24458     wxPrinter *arg1 = (wxPrinter *) 0 ;
24459     wxWindow *arg2 = (wxWindow *) 0 ;
24460     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24461     wxWindow *result;
24462     PyObject * obj0 = 0 ;
24463     PyObject * obj1 = 0 ;
24464     PyObject * obj2 = 0 ;
24465     char *kwnames[] = {
24466         (char *) "self",(char *) "parent",(char *) "printout", NULL
24467     };
24468
24469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printer_CreateAbortWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
24470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24471     if (SWIG_arg_fail(1)) SWIG_fail;
24472     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24473     if (SWIG_arg_fail(2)) SWIG_fail;
24474     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24475     if (SWIG_arg_fail(3)) SWIG_fail;
24476     {
24477         PyThreadState* __tstate = wxPyBeginAllowThreads();
24478         result = (wxWindow *)(arg1)->CreateAbortWindow(arg2,arg3);
24479
24480         wxPyEndAllowThreads(__tstate);
24481         if (PyErr_Occurred()) SWIG_fail;
24482     }
24483     {
24484         resultobj = wxPyMake_wxObject(result, 0);
24485     }
24486     return resultobj;
24487     fail:
24488     return NULL;
24489 }
24490
24491
24492 static PyObject *_wrap_Printer_ReportError(PyObject *, PyObject *args, PyObject *kwargs) {
24493     PyObject *resultobj;
24494     wxPrinter *arg1 = (wxPrinter *) 0 ;
24495     wxWindow *arg2 = (wxWindow *) 0 ;
24496     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24497     wxString *arg4 = 0 ;
24498     bool temp4 = false ;
24499     PyObject * obj0 = 0 ;
24500     PyObject * obj1 = 0 ;
24501     PyObject * obj2 = 0 ;
24502     PyObject * obj3 = 0 ;
24503     char *kwnames[] = {
24504         (char *) "self",(char *) "parent",(char *) "printout",(char *) "message", NULL
24505     };
24506
24507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Printer_ReportError",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24509     if (SWIG_arg_fail(1)) SWIG_fail;
24510     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24511     if (SWIG_arg_fail(2)) SWIG_fail;
24512     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24513     if (SWIG_arg_fail(3)) SWIG_fail;
24514     {
24515         arg4 = wxString_in_helper(obj3);
24516         if (arg4 == NULL) SWIG_fail;
24517         temp4 = true;
24518     }
24519     {
24520         PyThreadState* __tstate = wxPyBeginAllowThreads();
24521         (arg1)->ReportError(arg2,arg3,(wxString const &)*arg4);
24522
24523         wxPyEndAllowThreads(__tstate);
24524         if (PyErr_Occurred()) SWIG_fail;
24525     }
24526     Py_INCREF(Py_None); resultobj = Py_None;
24527     {
24528         if (temp4)
24529         delete arg4;
24530     }
24531     return resultobj;
24532     fail:
24533     {
24534         if (temp4)
24535         delete arg4;
24536     }
24537     return NULL;
24538 }
24539
24540
24541 static PyObject *_wrap_Printer_Setup(PyObject *, PyObject *args, PyObject *kwargs) {
24542     PyObject *resultobj;
24543     wxPrinter *arg1 = (wxPrinter *) 0 ;
24544     wxWindow *arg2 = (wxWindow *) 0 ;
24545     bool result;
24546     PyObject * obj0 = 0 ;
24547     PyObject * obj1 = 0 ;
24548     char *kwnames[] = {
24549         (char *) "self",(char *) "parent", NULL
24550     };
24551
24552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_Setup",kwnames,&obj0,&obj1)) goto fail;
24553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24554     if (SWIG_arg_fail(1)) SWIG_fail;
24555     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24556     if (SWIG_arg_fail(2)) SWIG_fail;
24557     {
24558         PyThreadState* __tstate = wxPyBeginAllowThreads();
24559         result = (bool)(arg1)->Setup(arg2);
24560
24561         wxPyEndAllowThreads(__tstate);
24562         if (PyErr_Occurred()) SWIG_fail;
24563     }
24564     {
24565         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24566     }
24567     return resultobj;
24568     fail:
24569     return NULL;
24570 }
24571
24572
24573 static PyObject *_wrap_Printer_Print(PyObject *, PyObject *args, PyObject *kwargs) {
24574     PyObject *resultobj;
24575     wxPrinter *arg1 = (wxPrinter *) 0 ;
24576     wxWindow *arg2 = (wxWindow *) 0 ;
24577     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24578     bool arg4 = (bool) true ;
24579     bool result;
24580     PyObject * obj0 = 0 ;
24581     PyObject * obj1 = 0 ;
24582     PyObject * obj2 = 0 ;
24583     PyObject * obj3 = 0 ;
24584     char *kwnames[] = {
24585         (char *) "self",(char *) "parent",(char *) "printout",(char *) "prompt", NULL
24586     };
24587
24588     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Printer_Print",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24589     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24590     if (SWIG_arg_fail(1)) SWIG_fail;
24591     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24592     if (SWIG_arg_fail(2)) SWIG_fail;
24593     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24594     if (SWIG_arg_fail(3)) SWIG_fail;
24595     if (obj3) {
24596         {
24597             arg4 = (bool)(SWIG_As_bool(obj3));
24598             if (SWIG_arg_fail(4)) SWIG_fail;
24599         }
24600     }
24601     {
24602         PyThreadState* __tstate = wxPyBeginAllowThreads();
24603         result = (bool)(arg1)->Print(arg2,arg3,arg4);
24604
24605         wxPyEndAllowThreads(__tstate);
24606         if (PyErr_Occurred()) SWIG_fail;
24607     }
24608     {
24609         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24610     }
24611     return resultobj;
24612     fail:
24613     return NULL;
24614 }
24615
24616
24617 static PyObject *_wrap_Printer_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24618     PyObject *resultobj;
24619     wxPrinter *arg1 = (wxPrinter *) 0 ;
24620     wxWindow *arg2 = (wxWindow *) 0 ;
24621     wxDC *result;
24622     PyObject * obj0 = 0 ;
24623     PyObject * obj1 = 0 ;
24624     char *kwnames[] = {
24625         (char *) "self",(char *) "parent", NULL
24626     };
24627
24628     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24629     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24630     if (SWIG_arg_fail(1)) SWIG_fail;
24631     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24632     if (SWIG_arg_fail(2)) SWIG_fail;
24633     {
24634         PyThreadState* __tstate = wxPyBeginAllowThreads();
24635         result = (wxDC *)(arg1)->PrintDialog(arg2);
24636
24637         wxPyEndAllowThreads(__tstate);
24638         if (PyErr_Occurred()) SWIG_fail;
24639     }
24640     {
24641         resultobj = wxPyMake_wxObject(result, 0);
24642     }
24643     return resultobj;
24644     fail:
24645     return NULL;
24646 }
24647
24648
24649 static PyObject *_wrap_Printer_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24650     PyObject *resultobj;
24651     wxPrinter *arg1 = (wxPrinter *) 0 ;
24652     wxPrintDialogData *result;
24653     PyObject * obj0 = 0 ;
24654     char *kwnames[] = {
24655         (char *) "self", NULL
24656     };
24657
24658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetPrintDialogData",kwnames,&obj0)) goto fail;
24659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24660     if (SWIG_arg_fail(1)) SWIG_fail;
24661     {
24662         PyThreadState* __tstate = wxPyBeginAllowThreads();
24663         {
24664             wxPrintDialogData &_result_ref = ((wxPrinter const *)arg1)->GetPrintDialogData();
24665             result = (wxPrintDialogData *) &_result_ref;
24666         }
24667
24668         wxPyEndAllowThreads(__tstate);
24669         if (PyErr_Occurred()) SWIG_fail;
24670     }
24671     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24672     return resultobj;
24673     fail:
24674     return NULL;
24675 }
24676
24677
24678 static PyObject *_wrap_Printer_GetAbort(PyObject *, PyObject *args, PyObject *kwargs) {
24679     PyObject *resultobj;
24680     wxPrinter *arg1 = (wxPrinter *) 0 ;
24681     bool result;
24682     PyObject * obj0 = 0 ;
24683     char *kwnames[] = {
24684         (char *) "self", NULL
24685     };
24686
24687     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetAbort",kwnames,&obj0)) goto fail;
24688     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24689     if (SWIG_arg_fail(1)) SWIG_fail;
24690     {
24691         PyThreadState* __tstate = wxPyBeginAllowThreads();
24692         result = (bool)(arg1)->GetAbort();
24693
24694         wxPyEndAllowThreads(__tstate);
24695         if (PyErr_Occurred()) SWIG_fail;
24696     }
24697     {
24698         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24699     }
24700     return resultobj;
24701     fail:
24702     return NULL;
24703 }
24704
24705
24706 static PyObject *_wrap_Printer_GetLastError(PyObject *, PyObject *args, PyObject *kwargs) {
24707     PyObject *resultobj;
24708     wxPrinterError result;
24709     char *kwnames[] = {
24710         NULL
24711     };
24712
24713     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Printer_GetLastError",kwnames)) goto fail;
24714     {
24715         PyThreadState* __tstate = wxPyBeginAllowThreads();
24716         result = (wxPrinterError)wxPrinter::GetLastError();
24717
24718         wxPyEndAllowThreads(__tstate);
24719         if (PyErr_Occurred()) SWIG_fail;
24720     }
24721     resultobj = SWIG_From_int((result));
24722     return resultobj;
24723     fail:
24724     return NULL;
24725 }
24726
24727
24728 static PyObject * Printer_swigregister(PyObject *, PyObject *args) {
24729     PyObject *obj;
24730     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24731     SWIG_TypeClientData(SWIGTYPE_p_wxPrinter, obj);
24732     Py_INCREF(obj);
24733     return Py_BuildValue((char *)"");
24734 }
24735 static PyObject *_wrap_new_Printout(PyObject *, PyObject *args, PyObject *kwargs) {
24736     PyObject *resultobj;
24737     wxString const &arg1_defvalue = wxPyPrintoutTitleStr ;
24738     wxString *arg1 = (wxString *) &arg1_defvalue ;
24739     wxPyPrintout *result;
24740     bool temp1 = false ;
24741     PyObject * obj0 = 0 ;
24742     char *kwnames[] = {
24743         (char *) "title", NULL
24744     };
24745
24746     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printout",kwnames,&obj0)) goto fail;
24747     if (obj0) {
24748         {
24749             arg1 = wxString_in_helper(obj0);
24750             if (arg1 == NULL) SWIG_fail;
24751             temp1 = true;
24752         }
24753     }
24754     {
24755         if (!wxPyCheckForApp()) SWIG_fail;
24756         PyThreadState* __tstate = wxPyBeginAllowThreads();
24757         result = (wxPyPrintout *)new wxPyPrintout((wxString const &)*arg1);
24758
24759         wxPyEndAllowThreads(__tstate);
24760         if (PyErr_Occurred()) SWIG_fail;
24761     }
24762     {
24763         resultobj = wxPyMake_wxObject(result, 1);
24764     }
24765     {
24766         if (temp1)
24767         delete arg1;
24768     }
24769     return resultobj;
24770     fail:
24771     {
24772         if (temp1)
24773         delete arg1;
24774     }
24775     return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_Printout__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24780     PyObject *resultobj;
24781     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24782     PyObject *arg2 = (PyObject *) 0 ;
24783     PyObject *arg3 = (PyObject *) 0 ;
24784     PyObject * obj0 = 0 ;
24785     PyObject * obj1 = 0 ;
24786     PyObject * obj2 = 0 ;
24787     char *kwnames[] = {
24788         (char *) "self",(char *) "self",(char *) "_class", NULL
24789     };
24790
24791     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24792     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24793     if (SWIG_arg_fail(1)) SWIG_fail;
24794     arg2 = obj1;
24795     arg3 = obj2;
24796     {
24797         PyThreadState* __tstate = wxPyBeginAllowThreads();
24798         (arg1)->_setCallbackInfo(arg2,arg3);
24799
24800         wxPyEndAllowThreads(__tstate);
24801         if (PyErr_Occurred()) SWIG_fail;
24802     }
24803     Py_INCREF(Py_None); resultobj = Py_None;
24804     return resultobj;
24805     fail:
24806     return NULL;
24807 }
24808
24809
24810 static PyObject *_wrap_Printout_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24811     PyObject *resultobj;
24812     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24813     wxString result;
24814     PyObject * obj0 = 0 ;
24815     char *kwnames[] = {
24816         (char *) "self", NULL
24817     };
24818
24819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetTitle",kwnames,&obj0)) goto fail;
24820     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24821     if (SWIG_arg_fail(1)) SWIG_fail;
24822     {
24823         PyThreadState* __tstate = wxPyBeginAllowThreads();
24824         result = ((wxPyPrintout const *)arg1)->GetTitle();
24825
24826         wxPyEndAllowThreads(__tstate);
24827         if (PyErr_Occurred()) SWIG_fail;
24828     }
24829     {
24830 #if wxUSE_UNICODE
24831         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24832 #else
24833         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24834 #endif
24835     }
24836     return resultobj;
24837     fail:
24838     return NULL;
24839 }
24840
24841
24842 static PyObject *_wrap_Printout_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24843     PyObject *resultobj;
24844     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24845     wxDC *result;
24846     PyObject * obj0 = 0 ;
24847     char *kwnames[] = {
24848         (char *) "self", NULL
24849     };
24850
24851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetDC",kwnames,&obj0)) goto fail;
24852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24853     if (SWIG_arg_fail(1)) SWIG_fail;
24854     {
24855         PyThreadState* __tstate = wxPyBeginAllowThreads();
24856         result = (wxDC *)(arg1)->GetDC();
24857
24858         wxPyEndAllowThreads(__tstate);
24859         if (PyErr_Occurred()) SWIG_fail;
24860     }
24861     {
24862         resultobj = wxPyMake_wxObject(result, 0);
24863     }
24864     return resultobj;
24865     fail:
24866     return NULL;
24867 }
24868
24869
24870 static PyObject *_wrap_Printout_SetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24871     PyObject *resultobj;
24872     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24873     wxDC *arg2 = (wxDC *) 0 ;
24874     PyObject * obj0 = 0 ;
24875     PyObject * obj1 = 0 ;
24876     char *kwnames[] = {
24877         (char *) "self",(char *) "dc", NULL
24878     };
24879
24880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetDC",kwnames,&obj0,&obj1)) goto fail;
24881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24882     if (SWIG_arg_fail(1)) SWIG_fail;
24883     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
24884     if (SWIG_arg_fail(2)) SWIG_fail;
24885     {
24886         PyThreadState* __tstate = wxPyBeginAllowThreads();
24887         (arg1)->SetDC(arg2);
24888
24889         wxPyEndAllowThreads(__tstate);
24890         if (PyErr_Occurred()) SWIG_fail;
24891     }
24892     Py_INCREF(Py_None); resultobj = Py_None;
24893     return resultobj;
24894     fail:
24895     return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24900     PyObject *resultobj;
24901     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24902     int arg2 ;
24903     int arg3 ;
24904     PyObject * obj0 = 0 ;
24905     PyObject * obj1 = 0 ;
24906     PyObject * obj2 = 0 ;
24907     char *kwnames[] = {
24908         (char *) "self",(char *) "w",(char *) "h", NULL
24909     };
24910
24911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizePixels",kwnames,&obj0,&obj1,&obj2)) goto fail;
24912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24913     if (SWIG_arg_fail(1)) SWIG_fail;
24914     {
24915         arg2 = (int)(SWIG_As_int(obj1));
24916         if (SWIG_arg_fail(2)) SWIG_fail;
24917     }
24918     {
24919         arg3 = (int)(SWIG_As_int(obj2));
24920         if (SWIG_arg_fail(3)) SWIG_fail;
24921     }
24922     {
24923         PyThreadState* __tstate = wxPyBeginAllowThreads();
24924         (arg1)->SetPageSizePixels(arg2,arg3);
24925
24926         wxPyEndAllowThreads(__tstate);
24927         if (PyErr_Occurred()) SWIG_fail;
24928     }
24929     Py_INCREF(Py_None); resultobj = Py_None;
24930     return resultobj;
24931     fail:
24932     return NULL;
24933 }
24934
24935
24936 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24937     PyObject *resultobj;
24938     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24939     int *arg2 = (int *) 0 ;
24940     int *arg3 = (int *) 0 ;
24941     int temp2 ;
24942     int res2 = 0 ;
24943     int temp3 ;
24944     int res3 = 0 ;
24945     PyObject * obj0 = 0 ;
24946     char *kwnames[] = {
24947         (char *) "self", NULL
24948     };
24949
24950     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24951     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizePixels",kwnames,&obj0)) goto fail;
24953     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24954     if (SWIG_arg_fail(1)) SWIG_fail;
24955     {
24956         PyThreadState* __tstate = wxPyBeginAllowThreads();
24957         (arg1)->GetPageSizePixels(arg2,arg3);
24958
24959         wxPyEndAllowThreads(__tstate);
24960         if (PyErr_Occurred()) SWIG_fail;
24961     }
24962     Py_INCREF(Py_None); resultobj = Py_None;
24963     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24964     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24965     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24966     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24967     return resultobj;
24968     fail:
24969     return NULL;
24970 }
24971
24972
24973 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24974     PyObject *resultobj;
24975     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24976     int arg2 ;
24977     int arg3 ;
24978     PyObject * obj0 = 0 ;
24979     PyObject * obj1 = 0 ;
24980     PyObject * obj2 = 0 ;
24981     char *kwnames[] = {
24982         (char *) "self",(char *) "w",(char *) "h", NULL
24983     };
24984
24985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizeMM",kwnames,&obj0,&obj1,&obj2)) goto fail;
24986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24987     if (SWIG_arg_fail(1)) SWIG_fail;
24988     {
24989         arg2 = (int)(SWIG_As_int(obj1));
24990         if (SWIG_arg_fail(2)) SWIG_fail;
24991     }
24992     {
24993         arg3 = (int)(SWIG_As_int(obj2));
24994         if (SWIG_arg_fail(3)) SWIG_fail;
24995     }
24996     {
24997         PyThreadState* __tstate = wxPyBeginAllowThreads();
24998         (arg1)->SetPageSizeMM(arg2,arg3);
24999
25000         wxPyEndAllowThreads(__tstate);
25001         if (PyErr_Occurred()) SWIG_fail;
25002     }
25003     Py_INCREF(Py_None); resultobj = Py_None;
25004     return resultobj;
25005     fail:
25006     return NULL;
25007 }
25008
25009
25010 static PyObject *_wrap_Printout_GetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
25011     PyObject *resultobj;
25012     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25013     int *arg2 = (int *) 0 ;
25014     int *arg3 = (int *) 0 ;
25015     int temp2 ;
25016     int res2 = 0 ;
25017     int temp3 ;
25018     int res3 = 0 ;
25019     PyObject * obj0 = 0 ;
25020     char *kwnames[] = {
25021         (char *) "self", NULL
25022     };
25023
25024     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25025     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizeMM",kwnames,&obj0)) goto fail;
25027     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25028     if (SWIG_arg_fail(1)) SWIG_fail;
25029     {
25030         PyThreadState* __tstate = wxPyBeginAllowThreads();
25031         (arg1)->GetPageSizeMM(arg2,arg3);
25032
25033         wxPyEndAllowThreads(__tstate);
25034         if (PyErr_Occurred()) SWIG_fail;
25035     }
25036     Py_INCREF(Py_None); resultobj = Py_None;
25037     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25038     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25039     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25040     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25041     return resultobj;
25042     fail:
25043     return NULL;
25044 }
25045
25046
25047 static PyObject *_wrap_Printout_SetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25048     PyObject *resultobj;
25049     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25050     int arg2 ;
25051     int arg3 ;
25052     PyObject * obj0 = 0 ;
25053     PyObject * obj1 = 0 ;
25054     PyObject * obj2 = 0 ;
25055     char *kwnames[] = {
25056         (char *) "self",(char *) "x",(char *) "y", NULL
25057     };
25058
25059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
25060     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25061     if (SWIG_arg_fail(1)) SWIG_fail;
25062     {
25063         arg2 = (int)(SWIG_As_int(obj1));
25064         if (SWIG_arg_fail(2)) SWIG_fail;
25065     }
25066     {
25067         arg3 = (int)(SWIG_As_int(obj2));
25068         if (SWIG_arg_fail(3)) SWIG_fail;
25069     }
25070     {
25071         PyThreadState* __tstate = wxPyBeginAllowThreads();
25072         (arg1)->SetPPIScreen(arg2,arg3);
25073
25074         wxPyEndAllowThreads(__tstate);
25075         if (PyErr_Occurred()) SWIG_fail;
25076     }
25077     Py_INCREF(Py_None); resultobj = Py_None;
25078     return resultobj;
25079     fail:
25080     return NULL;
25081 }
25082
25083
25084 static PyObject *_wrap_Printout_GetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25085     PyObject *resultobj;
25086     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25087     int *arg2 = (int *) 0 ;
25088     int *arg3 = (int *) 0 ;
25089     int temp2 ;
25090     int res2 = 0 ;
25091     int temp3 ;
25092     int res3 = 0 ;
25093     PyObject * obj0 = 0 ;
25094     char *kwnames[] = {
25095         (char *) "self", NULL
25096     };
25097
25098     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25099     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIScreen",kwnames,&obj0)) goto fail;
25101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25102     if (SWIG_arg_fail(1)) SWIG_fail;
25103     {
25104         PyThreadState* __tstate = wxPyBeginAllowThreads();
25105         (arg1)->GetPPIScreen(arg2,arg3);
25106
25107         wxPyEndAllowThreads(__tstate);
25108         if (PyErr_Occurred()) SWIG_fail;
25109     }
25110     Py_INCREF(Py_None); resultobj = Py_None;
25111     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25112     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25113     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25114     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25115     return resultobj;
25116     fail:
25117     return NULL;
25118 }
25119
25120
25121 static PyObject *_wrap_Printout_SetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
25122     PyObject *resultobj;
25123     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25124     int arg2 ;
25125     int arg3 ;
25126     PyObject * obj0 = 0 ;
25127     PyObject * obj1 = 0 ;
25128     PyObject * obj2 = 0 ;
25129     char *kwnames[] = {
25130         (char *) "self",(char *) "x",(char *) "y", NULL
25131     };
25132
25133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIPrinter",kwnames,&obj0,&obj1,&obj2)) goto fail;
25134     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25135     if (SWIG_arg_fail(1)) SWIG_fail;
25136     {
25137         arg2 = (int)(SWIG_As_int(obj1));
25138         if (SWIG_arg_fail(2)) SWIG_fail;
25139     }
25140     {
25141         arg3 = (int)(SWIG_As_int(obj2));
25142         if (SWIG_arg_fail(3)) SWIG_fail;
25143     }
25144     {
25145         PyThreadState* __tstate = wxPyBeginAllowThreads();
25146         (arg1)->SetPPIPrinter(arg2,arg3);
25147
25148         wxPyEndAllowThreads(__tstate);
25149         if (PyErr_Occurred()) SWIG_fail;
25150     }
25151     Py_INCREF(Py_None); resultobj = Py_None;
25152     return resultobj;
25153     fail:
25154     return NULL;
25155 }
25156
25157
25158 static PyObject *_wrap_Printout_GetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
25159     PyObject *resultobj;
25160     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25161     int *arg2 = (int *) 0 ;
25162     int *arg3 = (int *) 0 ;
25163     int temp2 ;
25164     int res2 = 0 ;
25165     int temp3 ;
25166     int res3 = 0 ;
25167     PyObject * obj0 = 0 ;
25168     char *kwnames[] = {
25169         (char *) "self", NULL
25170     };
25171
25172     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25173     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIPrinter",kwnames,&obj0)) goto fail;
25175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25176     if (SWIG_arg_fail(1)) SWIG_fail;
25177     {
25178         PyThreadState* __tstate = wxPyBeginAllowThreads();
25179         (arg1)->GetPPIPrinter(arg2,arg3);
25180
25181         wxPyEndAllowThreads(__tstate);
25182         if (PyErr_Occurred()) SWIG_fail;
25183     }
25184     Py_INCREF(Py_None); resultobj = Py_None;
25185     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25186     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25187     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25188     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25189     return resultobj;
25190     fail:
25191     return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_Printout_IsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25196     PyObject *resultobj;
25197     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25198     bool result;
25199     PyObject * obj0 = 0 ;
25200     char *kwnames[] = {
25201         (char *) "self", NULL
25202     };
25203
25204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_IsPreview",kwnames,&obj0)) goto fail;
25205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25206     if (SWIG_arg_fail(1)) SWIG_fail;
25207     {
25208         PyThreadState* __tstate = wxPyBeginAllowThreads();
25209         result = (bool)(arg1)->IsPreview();
25210
25211         wxPyEndAllowThreads(__tstate);
25212         if (PyErr_Occurred()) SWIG_fail;
25213     }
25214     {
25215         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25216     }
25217     return resultobj;
25218     fail:
25219     return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_Printout_SetIsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25224     PyObject *resultobj;
25225     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25226     bool arg2 ;
25227     PyObject * obj0 = 0 ;
25228     PyObject * obj1 = 0 ;
25229     char *kwnames[] = {
25230         (char *) "self",(char *) "p", NULL
25231     };
25232
25233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetIsPreview",kwnames,&obj0,&obj1)) goto fail;
25234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25235     if (SWIG_arg_fail(1)) SWIG_fail;
25236     {
25237         arg2 = (bool)(SWIG_As_bool(obj1));
25238         if (SWIG_arg_fail(2)) SWIG_fail;
25239     }
25240     {
25241         PyThreadState* __tstate = wxPyBeginAllowThreads();
25242         (arg1)->SetIsPreview(arg2);
25243
25244         wxPyEndAllowThreads(__tstate);
25245         if (PyErr_Occurred()) SWIG_fail;
25246     }
25247     Py_INCREF(Py_None); resultobj = Py_None;
25248     return resultobj;
25249     fail:
25250     return NULL;
25251 }
25252
25253
25254 static PyObject *_wrap_Printout_base_OnBeginDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25255     PyObject *resultobj;
25256     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25257     int arg2 ;
25258     int arg3 ;
25259     bool result;
25260     PyObject * obj0 = 0 ;
25261     PyObject * obj1 = 0 ;
25262     PyObject * obj2 = 0 ;
25263     char *kwnames[] = {
25264         (char *) "self",(char *) "startPage",(char *) "endPage", NULL
25265     };
25266
25267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_base_OnBeginDocument",kwnames,&obj0,&obj1,&obj2)) goto fail;
25268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25269     if (SWIG_arg_fail(1)) SWIG_fail;
25270     {
25271         arg2 = (int)(SWIG_As_int(obj1));
25272         if (SWIG_arg_fail(2)) SWIG_fail;
25273     }
25274     {
25275         arg3 = (int)(SWIG_As_int(obj2));
25276         if (SWIG_arg_fail(3)) SWIG_fail;
25277     }
25278     {
25279         PyThreadState* __tstate = wxPyBeginAllowThreads();
25280         result = (bool)(arg1)->base_OnBeginDocument(arg2,arg3);
25281
25282         wxPyEndAllowThreads(__tstate);
25283         if (PyErr_Occurred()) SWIG_fail;
25284     }
25285     {
25286         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25287     }
25288     return resultobj;
25289     fail:
25290     return NULL;
25291 }
25292
25293
25294 static PyObject *_wrap_Printout_base_OnEndDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25295     PyObject *resultobj;
25296     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25297     PyObject * obj0 = 0 ;
25298     char *kwnames[] = {
25299         (char *) "self", NULL
25300     };
25301
25302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndDocument",kwnames,&obj0)) goto fail;
25303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25304     if (SWIG_arg_fail(1)) SWIG_fail;
25305     {
25306         PyThreadState* __tstate = wxPyBeginAllowThreads();
25307         (arg1)->base_OnEndDocument();
25308
25309         wxPyEndAllowThreads(__tstate);
25310         if (PyErr_Occurred()) SWIG_fail;
25311     }
25312     Py_INCREF(Py_None); resultobj = Py_None;
25313     return resultobj;
25314     fail:
25315     return NULL;
25316 }
25317
25318
25319 static PyObject *_wrap_Printout_base_OnBeginPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25320     PyObject *resultobj;
25321     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25322     PyObject * obj0 = 0 ;
25323     char *kwnames[] = {
25324         (char *) "self", NULL
25325     };
25326
25327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnBeginPrinting",kwnames,&obj0)) goto fail;
25328     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25329     if (SWIG_arg_fail(1)) SWIG_fail;
25330     {
25331         PyThreadState* __tstate = wxPyBeginAllowThreads();
25332         (arg1)->base_OnBeginPrinting();
25333
25334         wxPyEndAllowThreads(__tstate);
25335         if (PyErr_Occurred()) SWIG_fail;
25336     }
25337     Py_INCREF(Py_None); resultobj = Py_None;
25338     return resultobj;
25339     fail:
25340     return NULL;
25341 }
25342
25343
25344 static PyObject *_wrap_Printout_base_OnEndPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25345     PyObject *resultobj;
25346     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25347     PyObject * obj0 = 0 ;
25348     char *kwnames[] = {
25349         (char *) "self", NULL
25350     };
25351
25352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndPrinting",kwnames,&obj0)) goto fail;
25353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25354     if (SWIG_arg_fail(1)) SWIG_fail;
25355     {
25356         PyThreadState* __tstate = wxPyBeginAllowThreads();
25357         (arg1)->base_OnEndPrinting();
25358
25359         wxPyEndAllowThreads(__tstate);
25360         if (PyErr_Occurred()) SWIG_fail;
25361     }
25362     Py_INCREF(Py_None); resultobj = Py_None;
25363     return resultobj;
25364     fail:
25365     return NULL;
25366 }
25367
25368
25369 static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25370     PyObject *resultobj;
25371     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25372     PyObject * obj0 = 0 ;
25373     char *kwnames[] = {
25374         (char *) "self", NULL
25375     };
25376
25377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnPreparePrinting",kwnames,&obj0)) goto fail;
25378     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25379     if (SWIG_arg_fail(1)) SWIG_fail;
25380     {
25381         PyThreadState* __tstate = wxPyBeginAllowThreads();
25382         (arg1)->base_OnPreparePrinting();
25383
25384         wxPyEndAllowThreads(__tstate);
25385         if (PyErr_Occurred()) SWIG_fail;
25386     }
25387     Py_INCREF(Py_None); resultobj = Py_None;
25388     return resultobj;
25389     fail:
25390     return NULL;
25391 }
25392
25393
25394 static PyObject *_wrap_Printout_base_HasPage(PyObject *, PyObject *args, PyObject *kwargs) {
25395     PyObject *resultobj;
25396     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25397     int arg2 ;
25398     bool result;
25399     PyObject * obj0 = 0 ;
25400     PyObject * obj1 = 0 ;
25401     char *kwnames[] = {
25402         (char *) "self",(char *) "page", NULL
25403     };
25404
25405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_base_HasPage",kwnames,&obj0,&obj1)) goto fail;
25406     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25407     if (SWIG_arg_fail(1)) SWIG_fail;
25408     {
25409         arg2 = (int)(SWIG_As_int(obj1));
25410         if (SWIG_arg_fail(2)) SWIG_fail;
25411     }
25412     {
25413         PyThreadState* __tstate = wxPyBeginAllowThreads();
25414         result = (bool)(arg1)->base_HasPage(arg2);
25415
25416         wxPyEndAllowThreads(__tstate);
25417         if (PyErr_Occurred()) SWIG_fail;
25418     }
25419     {
25420         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25421     }
25422     return resultobj;
25423     fail:
25424     return NULL;
25425 }
25426
25427
25428 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
25429     PyObject *resultobj;
25430     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25431     int *arg2 = (int *) 0 ;
25432     int *arg3 = (int *) 0 ;
25433     int *arg4 = (int *) 0 ;
25434     int *arg5 = (int *) 0 ;
25435     int temp2 ;
25436     int res2 = 0 ;
25437     int temp3 ;
25438     int res3 = 0 ;
25439     int temp4 ;
25440     int res4 = 0 ;
25441     int temp5 ;
25442     int res5 = 0 ;
25443     PyObject * obj0 = 0 ;
25444     char *kwnames[] = {
25445         (char *) "self", NULL
25446     };
25447
25448     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25449     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25450     arg4 = &temp4; res4 = SWIG_NEWOBJ;
25451     arg5 = &temp5; res5 = SWIG_NEWOBJ;
25452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_GetPageInfo",kwnames,&obj0)) goto fail;
25453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25454     if (SWIG_arg_fail(1)) SWIG_fail;
25455     {
25456         PyThreadState* __tstate = wxPyBeginAllowThreads();
25457         (arg1)->base_GetPageInfo(arg2,arg3,arg4,arg5);
25458
25459         wxPyEndAllowThreads(__tstate);
25460         if (PyErr_Occurred()) SWIG_fail;
25461     }
25462     Py_INCREF(Py_None); resultobj = Py_None;
25463     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25464     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25465     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25466     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25467     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
25468     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
25469     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
25470     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
25471     return resultobj;
25472     fail:
25473     return NULL;
25474 }
25475
25476
25477 static PyObject * Printout_swigregister(PyObject *, PyObject *args) {
25478     PyObject *obj;
25479     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25480     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintout, obj);
25481     Py_INCREF(obj);
25482     return Py_BuildValue((char *)"");
25483 }
25484 static PyObject *_wrap_new_PreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25485     PyObject *resultobj;
25486     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25487     wxWindow *arg2 = (wxWindow *) 0 ;
25488     wxPoint const &arg3_defvalue = wxDefaultPosition ;
25489     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25490     wxSize const &arg4_defvalue = wxDefaultSize ;
25491     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25492     long arg5 = (long) 0 ;
25493     wxString const &arg6_defvalue = wxPyPreviewCanvasNameStr ;
25494     wxString *arg6 = (wxString *) &arg6_defvalue ;
25495     wxPreviewCanvas *result;
25496     wxPoint temp3 ;
25497     wxSize temp4 ;
25498     bool temp6 = false ;
25499     PyObject * obj0 = 0 ;
25500     PyObject * obj1 = 0 ;
25501     PyObject * obj2 = 0 ;
25502     PyObject * obj3 = 0 ;
25503     PyObject * obj4 = 0 ;
25504     PyObject * obj5 = 0 ;
25505     char *kwnames[] = {
25506         (char *) "preview",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25507     };
25508
25509     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PreviewCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25510     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25511     if (SWIG_arg_fail(1)) SWIG_fail;
25512     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25513     if (SWIG_arg_fail(2)) SWIG_fail;
25514     if (obj2) {
25515         {
25516             arg3 = &temp3;
25517             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25518         }
25519     }
25520     if (obj3) {
25521         {
25522             arg4 = &temp4;
25523             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25524         }
25525     }
25526     if (obj4) {
25527         {
25528             arg5 = (long)(SWIG_As_long(obj4));
25529             if (SWIG_arg_fail(5)) SWIG_fail;
25530         }
25531     }
25532     if (obj5) {
25533         {
25534             arg6 = wxString_in_helper(obj5);
25535             if (arg6 == NULL) SWIG_fail;
25536             temp6 = true;
25537         }
25538     }
25539     {
25540         if (!wxPyCheckForApp()) SWIG_fail;
25541         PyThreadState* __tstate = wxPyBeginAllowThreads();
25542         result = (wxPreviewCanvas *)new wxPreviewCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25543
25544         wxPyEndAllowThreads(__tstate);
25545         if (PyErr_Occurred()) SWIG_fail;
25546     }
25547     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 1);
25548     {
25549         if (temp6)
25550         delete arg6;
25551     }
25552     return resultobj;
25553     fail:
25554     {
25555         if (temp6)
25556         delete arg6;
25557     }
25558     return NULL;
25559 }
25560
25561
25562 static PyObject * PreviewCanvas_swigregister(PyObject *, PyObject *args) {
25563     PyObject *obj;
25564     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25565     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewCanvas, obj);
25566     Py_INCREF(obj);
25567     return Py_BuildValue((char *)"");
25568 }
25569 static PyObject *_wrap_new_PreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
25570     PyObject *resultobj;
25571     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25572     wxFrame *arg2 = (wxFrame *) 0 ;
25573     wxString *arg3 = 0 ;
25574     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25575     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25576     wxSize const &arg5_defvalue = wxDefaultSize ;
25577     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25578     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
25579     wxString const &arg7_defvalue = wxPyFrameNameStr ;
25580     wxString *arg7 = (wxString *) &arg7_defvalue ;
25581     wxPreviewFrame *result;
25582     bool temp3 = false ;
25583     wxPoint temp4 ;
25584     wxSize temp5 ;
25585     bool temp7 = false ;
25586     PyObject * obj0 = 0 ;
25587     PyObject * obj1 = 0 ;
25588     PyObject * obj2 = 0 ;
25589     PyObject * obj3 = 0 ;
25590     PyObject * obj4 = 0 ;
25591     PyObject * obj5 = 0 ;
25592     PyObject * obj6 = 0 ;
25593     char *kwnames[] = {
25594         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25595     };
25596
25597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25598     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25599     if (SWIG_arg_fail(1)) SWIG_fail;
25600     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
25601     if (SWIG_arg_fail(2)) SWIG_fail;
25602     {
25603         arg3 = wxString_in_helper(obj2);
25604         if (arg3 == NULL) SWIG_fail;
25605         temp3 = true;
25606     }
25607     if (obj3) {
25608         {
25609             arg4 = &temp4;
25610             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25611         }
25612     }
25613     if (obj4) {
25614         {
25615             arg5 = &temp5;
25616             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25617         }
25618     }
25619     if (obj5) {
25620         {
25621             arg6 = (long)(SWIG_As_long(obj5));
25622             if (SWIG_arg_fail(6)) SWIG_fail;
25623         }
25624     }
25625     if (obj6) {
25626         {
25627             arg7 = wxString_in_helper(obj6);
25628             if (arg7 == NULL) SWIG_fail;
25629             temp7 = true;
25630         }
25631     }
25632     {
25633         if (!wxPyCheckForApp()) SWIG_fail;
25634         PyThreadState* __tstate = wxPyBeginAllowThreads();
25635         result = (wxPreviewFrame *)new wxPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25636
25637         wxPyEndAllowThreads(__tstate);
25638         if (PyErr_Occurred()) SWIG_fail;
25639     }
25640     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewFrame, 1);
25641     {
25642         if (temp3)
25643         delete arg3;
25644     }
25645     {
25646         if (temp7)
25647         delete arg7;
25648     }
25649     return resultobj;
25650     fail:
25651     {
25652         if (temp3)
25653         delete arg3;
25654     }
25655     {
25656         if (temp7)
25657         delete arg7;
25658     }
25659     return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_PreviewFrame_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
25664     PyObject *resultobj;
25665     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25666     PyObject * obj0 = 0 ;
25667     char *kwnames[] = {
25668         (char *) "self", NULL
25669     };
25670
25671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_Initialize",kwnames,&obj0)) goto fail;
25672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25673     if (SWIG_arg_fail(1)) SWIG_fail;
25674     {
25675         PyThreadState* __tstate = wxPyBeginAllowThreads();
25676         (arg1)->Initialize();
25677
25678         wxPyEndAllowThreads(__tstate);
25679         if (PyErr_Occurred()) SWIG_fail;
25680     }
25681     Py_INCREF(Py_None); resultobj = Py_None;
25682     return resultobj;
25683     fail:
25684     return NULL;
25685 }
25686
25687
25688 static PyObject *_wrap_PreviewFrame_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25689     PyObject *resultobj;
25690     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25691     PyObject * obj0 = 0 ;
25692     char *kwnames[] = {
25693         (char *) "self", NULL
25694     };
25695
25696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateControlBar",kwnames,&obj0)) goto fail;
25697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25698     if (SWIG_arg_fail(1)) SWIG_fail;
25699     {
25700         PyThreadState* __tstate = wxPyBeginAllowThreads();
25701         (arg1)->CreateControlBar();
25702
25703         wxPyEndAllowThreads(__tstate);
25704         if (PyErr_Occurred()) SWIG_fail;
25705     }
25706     Py_INCREF(Py_None); resultobj = Py_None;
25707     return resultobj;
25708     fail:
25709     return NULL;
25710 }
25711
25712
25713 static PyObject *_wrap_PreviewFrame_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25714     PyObject *resultobj;
25715     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25716     PyObject * obj0 = 0 ;
25717     char *kwnames[] = {
25718         (char *) "self", NULL
25719     };
25720
25721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateCanvas",kwnames,&obj0)) goto fail;
25722     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25723     if (SWIG_arg_fail(1)) SWIG_fail;
25724     {
25725         PyThreadState* __tstate = wxPyBeginAllowThreads();
25726         (arg1)->CreateCanvas();
25727
25728         wxPyEndAllowThreads(__tstate);
25729         if (PyErr_Occurred()) SWIG_fail;
25730     }
25731     Py_INCREF(Py_None); resultobj = Py_None;
25732     return resultobj;
25733     fail:
25734     return NULL;
25735 }
25736
25737
25738 static PyObject *_wrap_PreviewFrame_GetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25739     PyObject *resultobj;
25740     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25741     wxPreviewControlBar *result;
25742     PyObject * obj0 = 0 ;
25743     char *kwnames[] = {
25744         (char *) "self", NULL
25745     };
25746
25747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_GetControlBar",kwnames,&obj0)) goto fail;
25748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25749     if (SWIG_arg_fail(1)) SWIG_fail;
25750     {
25751         PyThreadState* __tstate = wxPyBeginAllowThreads();
25752         result = (wxPreviewControlBar *)((wxPreviewFrame const *)arg1)->GetControlBar();
25753
25754         wxPyEndAllowThreads(__tstate);
25755         if (PyErr_Occurred()) SWIG_fail;
25756     }
25757     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 0);
25758     return resultobj;
25759     fail:
25760     return NULL;
25761 }
25762
25763
25764 static PyObject * PreviewFrame_swigregister(PyObject *, PyObject *args) {
25765     PyObject *obj;
25766     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25767     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewFrame, obj);
25768     Py_INCREF(obj);
25769     return Py_BuildValue((char *)"");
25770 }
25771 static PyObject *_wrap_new_PreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25772     PyObject *resultobj;
25773     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25774     long arg2 ;
25775     wxWindow *arg3 = (wxWindow *) 0 ;
25776     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25777     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25778     wxSize const &arg5_defvalue = wxDefaultSize ;
25779     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25780     long arg6 = (long) wxTAB_TRAVERSAL ;
25781     wxString const &arg7_defvalue = wxPyPanelNameStr ;
25782     wxString *arg7 = (wxString *) &arg7_defvalue ;
25783     wxPreviewControlBar *result;
25784     wxPoint temp4 ;
25785     wxSize temp5 ;
25786     bool temp7 = false ;
25787     PyObject * obj0 = 0 ;
25788     PyObject * obj1 = 0 ;
25789     PyObject * obj2 = 0 ;
25790     PyObject * obj3 = 0 ;
25791     PyObject * obj4 = 0 ;
25792     PyObject * obj5 = 0 ;
25793     PyObject * obj6 = 0 ;
25794     char *kwnames[] = {
25795         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25796     };
25797
25798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25800     if (SWIG_arg_fail(1)) SWIG_fail;
25801     {
25802         arg2 = (long)(SWIG_As_long(obj1));
25803         if (SWIG_arg_fail(2)) SWIG_fail;
25804     }
25805     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25806     if (SWIG_arg_fail(3)) SWIG_fail;
25807     if (obj3) {
25808         {
25809             arg4 = &temp4;
25810             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25811         }
25812     }
25813     if (obj4) {
25814         {
25815             arg5 = &temp5;
25816             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25817         }
25818     }
25819     if (obj5) {
25820         {
25821             arg6 = (long)(SWIG_As_long(obj5));
25822             if (SWIG_arg_fail(6)) SWIG_fail;
25823         }
25824     }
25825     if (obj6) {
25826         {
25827             arg7 = wxString_in_helper(obj6);
25828             if (arg7 == NULL) SWIG_fail;
25829             temp7 = true;
25830         }
25831     }
25832     {
25833         if (!wxPyCheckForApp()) SWIG_fail;
25834         PyThreadState* __tstate = wxPyBeginAllowThreads();
25835         result = (wxPreviewControlBar *)new wxPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25836
25837         wxPyEndAllowThreads(__tstate);
25838         if (PyErr_Occurred()) SWIG_fail;
25839     }
25840     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 1);
25841     {
25842         if (temp7)
25843         delete arg7;
25844     }
25845     return resultobj;
25846     fail:
25847     {
25848         if (temp7)
25849         delete arg7;
25850     }
25851     return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_PreviewControlBar_GetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25856     PyObject *resultobj;
25857     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25858     int result;
25859     PyObject * obj0 = 0 ;
25860     char *kwnames[] = {
25861         (char *) "self", NULL
25862     };
25863
25864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetZoomControl",kwnames,&obj0)) goto fail;
25865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25866     if (SWIG_arg_fail(1)) SWIG_fail;
25867     {
25868         PyThreadState* __tstate = wxPyBeginAllowThreads();
25869         result = (int)(arg1)->GetZoomControl();
25870
25871         wxPyEndAllowThreads(__tstate);
25872         if (PyErr_Occurred()) SWIG_fail;
25873     }
25874     {
25875         resultobj = SWIG_From_int((int)(result));
25876     }
25877     return resultobj;
25878     fail:
25879     return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_PreviewControlBar_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25884     PyObject *resultobj;
25885     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25886     int arg2 ;
25887     PyObject * obj0 = 0 ;
25888     PyObject * obj1 = 0 ;
25889     char *kwnames[] = {
25890         (char *) "self",(char *) "zoom", NULL
25891     };
25892
25893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PreviewControlBar_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
25894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25895     if (SWIG_arg_fail(1)) SWIG_fail;
25896     {
25897         arg2 = (int)(SWIG_As_int(obj1));
25898         if (SWIG_arg_fail(2)) SWIG_fail;
25899     }
25900     {
25901         PyThreadState* __tstate = wxPyBeginAllowThreads();
25902         (arg1)->SetZoomControl(arg2);
25903
25904         wxPyEndAllowThreads(__tstate);
25905         if (PyErr_Occurred()) SWIG_fail;
25906     }
25907     Py_INCREF(Py_None); resultobj = Py_None;
25908     return resultobj;
25909     fail:
25910     return NULL;
25911 }
25912
25913
25914 static PyObject *_wrap_PreviewControlBar_GetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25915     PyObject *resultobj;
25916     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25917     wxPrintPreview *result;
25918     PyObject * obj0 = 0 ;
25919     char *kwnames[] = {
25920         (char *) "self", NULL
25921     };
25922
25923     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetPrintPreview",kwnames,&obj0)) goto fail;
25924     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25925     if (SWIG_arg_fail(1)) SWIG_fail;
25926     {
25927         PyThreadState* __tstate = wxPyBeginAllowThreads();
25928         result = (wxPrintPreview *)(arg1)->GetPrintPreview();
25929
25930         wxPyEndAllowThreads(__tstate);
25931         if (PyErr_Occurred()) SWIG_fail;
25932     }
25933     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 0);
25934     return resultobj;
25935     fail:
25936     return NULL;
25937 }
25938
25939
25940 static PyObject *_wrap_PreviewControlBar_OnNext(PyObject *, PyObject *args, PyObject *kwargs) {
25941     PyObject *resultobj;
25942     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25943     PyObject * obj0 = 0 ;
25944     char *kwnames[] = {
25945         (char *) "self", NULL
25946     };
25947
25948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnNext",kwnames,&obj0)) goto fail;
25949     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25950     if (SWIG_arg_fail(1)) SWIG_fail;
25951     {
25952         PyThreadState* __tstate = wxPyBeginAllowThreads();
25953         (arg1)->OnNext();
25954
25955         wxPyEndAllowThreads(__tstate);
25956         if (PyErr_Occurred()) SWIG_fail;
25957     }
25958     Py_INCREF(Py_None); resultobj = Py_None;
25959     return resultobj;
25960     fail:
25961     return NULL;
25962 }
25963
25964
25965 static PyObject *_wrap_PreviewControlBar_OnPrevious(PyObject *, PyObject *args, PyObject *kwargs) {
25966     PyObject *resultobj;
25967     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25968     PyObject * obj0 = 0 ;
25969     char *kwnames[] = {
25970         (char *) "self", NULL
25971     };
25972
25973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnPrevious",kwnames,&obj0)) goto fail;
25974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25975     if (SWIG_arg_fail(1)) SWIG_fail;
25976     {
25977         PyThreadState* __tstate = wxPyBeginAllowThreads();
25978         (arg1)->OnPrevious();
25979
25980         wxPyEndAllowThreads(__tstate);
25981         if (PyErr_Occurred()) SWIG_fail;
25982     }
25983     Py_INCREF(Py_None); resultobj = Py_None;
25984     return resultobj;
25985     fail:
25986     return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_PreviewControlBar_OnFirst(PyObject *, PyObject *args, PyObject *kwargs) {
25991     PyObject *resultobj;
25992     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25993     PyObject * obj0 = 0 ;
25994     char *kwnames[] = {
25995         (char *) "self", NULL
25996     };
25997
25998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnFirst",kwnames,&obj0)) goto fail;
25999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
26000     if (SWIG_arg_fail(1)) SWIG_fail;
26001     {
26002         PyThreadState* __tstate = wxPyBeginAllowThreads();
26003         (arg1)->OnFirst();
26004
26005         wxPyEndAllowThreads(__tstate);
26006         if (PyErr_Occurred()) SWIG_fail;
26007     }
26008     Py_INCREF(Py_None); resultobj = Py_None;
26009     return resultobj;
26010     fail:
26011     return NULL;
26012 }
26013
26014
26015 static PyObject *_wrap_PreviewControlBar_OnLast(PyObject *, PyObject *args, PyObject *kwargs) {
26016     PyObject *resultobj;
26017     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
26018     PyObject * obj0 = 0 ;
26019     char *kwnames[] = {
26020         (char *) "self", NULL
26021     };
26022
26023     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnLast",kwnames,&obj0)) goto fail;
26024     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
26025     if (SWIG_arg_fail(1)) SWIG_fail;
26026     {
26027         PyThreadState* __tstate = wxPyBeginAllowThreads();
26028         (arg1)->OnLast();
26029
26030         wxPyEndAllowThreads(__tstate);
26031         if (PyErr_Occurred()) SWIG_fail;
26032     }
26033     Py_INCREF(Py_None); resultobj = Py_None;
26034     return resultobj;
26035     fail:
26036     return NULL;
26037 }
26038
26039
26040 static PyObject *_wrap_PreviewControlBar_OnGoto(PyObject *, PyObject *args, PyObject *kwargs) {
26041     PyObject *resultobj;
26042     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
26043     PyObject * obj0 = 0 ;
26044     char *kwnames[] = {
26045         (char *) "self", NULL
26046     };
26047
26048     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnGoto",kwnames,&obj0)) goto fail;
26049     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
26050     if (SWIG_arg_fail(1)) SWIG_fail;
26051     {
26052         PyThreadState* __tstate = wxPyBeginAllowThreads();
26053         (arg1)->OnGoto();
26054
26055         wxPyEndAllowThreads(__tstate);
26056         if (PyErr_Occurred()) SWIG_fail;
26057     }
26058     Py_INCREF(Py_None); resultobj = Py_None;
26059     return resultobj;
26060     fail:
26061     return NULL;
26062 }
26063
26064
26065 static PyObject * PreviewControlBar_swigregister(PyObject *, PyObject *args) {
26066     PyObject *obj;
26067     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26068     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewControlBar, obj);
26069     Py_INCREF(obj);
26070     return Py_BuildValue((char *)"");
26071 }
26072 static PyObject *_wrap_new_PrintPreview__SWIG_0(PyObject *, PyObject *args) {
26073     PyObject *resultobj;
26074     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26075     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26076     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26077     wxPrintPreview *result;
26078     PyObject * obj0 = 0 ;
26079     PyObject * obj1 = 0 ;
26080     PyObject * obj2 = 0 ;
26081
26082     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
26083     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26084     if (SWIG_arg_fail(1)) SWIG_fail;
26085     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26086     if (SWIG_arg_fail(2)) SWIG_fail;
26087     if (obj2) {
26088         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26089         if (SWIG_arg_fail(3)) SWIG_fail;
26090     }
26091     {
26092         if (!wxPyCheckForApp()) SWIG_fail;
26093         PyThreadState* __tstate = wxPyBeginAllowThreads();
26094         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
26095
26096         wxPyEndAllowThreads(__tstate);
26097         if (PyErr_Occurred()) SWIG_fail;
26098     }
26099     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
26100     return resultobj;
26101     fail:
26102     return NULL;
26103 }
26104
26105
26106 static PyObject *_wrap_new_PrintPreview__SWIG_1(PyObject *, PyObject *args) {
26107     PyObject *resultobj;
26108     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26109     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26110     wxPrintData *arg3 = (wxPrintData *) 0 ;
26111     wxPrintPreview *result;
26112     PyObject * obj0 = 0 ;
26113     PyObject * obj1 = 0 ;
26114     PyObject * obj2 = 0 ;
26115
26116     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
26117     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26118     if (SWIG_arg_fail(1)) SWIG_fail;
26119     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26120     if (SWIG_arg_fail(2)) SWIG_fail;
26121     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26122     if (SWIG_arg_fail(3)) SWIG_fail;
26123     {
26124         if (!wxPyCheckForApp()) SWIG_fail;
26125         PyThreadState* __tstate = wxPyBeginAllowThreads();
26126         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
26127
26128         wxPyEndAllowThreads(__tstate);
26129         if (PyErr_Occurred()) SWIG_fail;
26130     }
26131     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
26132     return resultobj;
26133     fail:
26134     return NULL;
26135 }
26136
26137
26138 static PyObject *_wrap_new_PrintPreview(PyObject *self, PyObject *args) {
26139     int argc;
26140     PyObject *argv[4];
26141     int ii;
26142
26143     argc = PyObject_Length(args);
26144     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26145         argv[ii] = PyTuple_GetItem(args,ii);
26146     }
26147     if ((argc >= 2) && (argc <= 3)) {
26148         int _v;
26149         {
26150             void *ptr;
26151             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26152                 _v = 0;
26153                 PyErr_Clear();
26154             } else {
26155                 _v = 1;
26156             }
26157         }
26158         if (_v) {
26159             {
26160                 void *ptr;
26161                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26162                     _v = 0;
26163                     PyErr_Clear();
26164                 } else {
26165                     _v = 1;
26166                 }
26167             }
26168             if (_v) {
26169                 if (argc <= 2) {
26170                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26171                 }
26172                 {
26173                     void *ptr;
26174                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26175                         _v = 0;
26176                         PyErr_Clear();
26177                     } else {
26178                         _v = 1;
26179                     }
26180                 }
26181                 if (_v) {
26182                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26183                 }
26184             }
26185         }
26186     }
26187     if (argc == 3) {
26188         int _v;
26189         {
26190             void *ptr;
26191             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26192                 _v = 0;
26193                 PyErr_Clear();
26194             } else {
26195                 _v = 1;
26196             }
26197         }
26198         if (_v) {
26199             {
26200                 void *ptr;
26201                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26202                     _v = 0;
26203                     PyErr_Clear();
26204                 } else {
26205                     _v = 1;
26206                 }
26207             }
26208             if (_v) {
26209                 {
26210                     void *ptr;
26211                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26212                         _v = 0;
26213                         PyErr_Clear();
26214                     } else {
26215                         _v = 1;
26216                     }
26217                 }
26218                 if (_v) {
26219                     return _wrap_new_PrintPreview__SWIG_1(self,args);
26220                 }
26221             }
26222         }
26223     }
26224
26225     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintPreview'");
26226     return NULL;
26227 }
26228
26229
26230 static PyObject *_wrap_PrintPreview_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26231     PyObject *resultobj;
26232     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26233     int arg2 ;
26234     bool result;
26235     PyObject * obj0 = 0 ;
26236     PyObject * obj1 = 0 ;
26237     char *kwnames[] = {
26238         (char *) "self",(char *) "pageNum", NULL
26239     };
26240
26241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26243     if (SWIG_arg_fail(1)) SWIG_fail;
26244     {
26245         arg2 = (int)(SWIG_As_int(obj1));
26246         if (SWIG_arg_fail(2)) SWIG_fail;
26247     }
26248     {
26249         PyThreadState* __tstate = wxPyBeginAllowThreads();
26250         result = (bool)(arg1)->SetCurrentPage(arg2);
26251
26252         wxPyEndAllowThreads(__tstate);
26253         if (PyErr_Occurred()) SWIG_fail;
26254     }
26255     {
26256         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26257     }
26258     return resultobj;
26259     fail:
26260     return NULL;
26261 }
26262
26263
26264 static PyObject *_wrap_PrintPreview_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26265     PyObject *resultobj;
26266     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26267     int result;
26268     PyObject * obj0 = 0 ;
26269     char *kwnames[] = {
26270         (char *) "self", NULL
26271     };
26272
26273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCurrentPage",kwnames,&obj0)) goto fail;
26274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26275     if (SWIG_arg_fail(1)) SWIG_fail;
26276     {
26277         PyThreadState* __tstate = wxPyBeginAllowThreads();
26278         result = (int)(arg1)->GetCurrentPage();
26279
26280         wxPyEndAllowThreads(__tstate);
26281         if (PyErr_Occurred()) SWIG_fail;
26282     }
26283     {
26284         resultobj = SWIG_From_int((int)(result));
26285     }
26286     return resultobj;
26287     fail:
26288     return NULL;
26289 }
26290
26291
26292 static PyObject *_wrap_PrintPreview_SetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26293     PyObject *resultobj;
26294     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26295     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26296     PyObject * obj0 = 0 ;
26297     PyObject * obj1 = 0 ;
26298     char *kwnames[] = {
26299         (char *) "self",(char *) "printout", NULL
26300     };
26301
26302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetPrintout",kwnames,&obj0,&obj1)) goto fail;
26303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26304     if (SWIG_arg_fail(1)) SWIG_fail;
26305     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26306     if (SWIG_arg_fail(2)) SWIG_fail;
26307     {
26308         PyThreadState* __tstate = wxPyBeginAllowThreads();
26309         (arg1)->SetPrintout(arg2);
26310
26311         wxPyEndAllowThreads(__tstate);
26312         if (PyErr_Occurred()) SWIG_fail;
26313     }
26314     Py_INCREF(Py_None); resultobj = Py_None;
26315     return resultobj;
26316     fail:
26317     return NULL;
26318 }
26319
26320
26321 static PyObject *_wrap_PrintPreview_GetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26322     PyObject *resultobj;
26323     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26324     wxPyPrintout *result;
26325     PyObject * obj0 = 0 ;
26326     char *kwnames[] = {
26327         (char *) "self", NULL
26328     };
26329
26330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintout",kwnames,&obj0)) goto fail;
26331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26332     if (SWIG_arg_fail(1)) SWIG_fail;
26333     {
26334         PyThreadState* __tstate = wxPyBeginAllowThreads();
26335         result = (wxPyPrintout *)(arg1)->GetPrintout();
26336
26337         wxPyEndAllowThreads(__tstate);
26338         if (PyErr_Occurred()) SWIG_fail;
26339     }
26340     {
26341         resultobj = wxPyMake_wxObject(result, 0);
26342     }
26343     return resultobj;
26344     fail:
26345     return NULL;
26346 }
26347
26348
26349 static PyObject *_wrap_PrintPreview_GetPrintoutForPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
26350     PyObject *resultobj;
26351     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26352     wxPyPrintout *result;
26353     PyObject * obj0 = 0 ;
26354     char *kwnames[] = {
26355         (char *) "self", NULL
26356     };
26357
26358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintoutForPrinting",kwnames,&obj0)) goto fail;
26359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26360     if (SWIG_arg_fail(1)) SWIG_fail;
26361     {
26362         PyThreadState* __tstate = wxPyBeginAllowThreads();
26363         result = (wxPyPrintout *)(arg1)->GetPrintoutForPrinting();
26364
26365         wxPyEndAllowThreads(__tstate);
26366         if (PyErr_Occurred()) SWIG_fail;
26367     }
26368     {
26369         resultobj = wxPyMake_wxObject(result, 0);
26370     }
26371     return resultobj;
26372     fail:
26373     return NULL;
26374 }
26375
26376
26377 static PyObject *_wrap_PrintPreview_SetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26378     PyObject *resultobj;
26379     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26380     wxFrame *arg2 = (wxFrame *) 0 ;
26381     PyObject * obj0 = 0 ;
26382     PyObject * obj1 = 0 ;
26383     char *kwnames[] = {
26384         (char *) "self",(char *) "frame", NULL
26385     };
26386
26387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetFrame",kwnames,&obj0,&obj1)) goto fail;
26388     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26389     if (SWIG_arg_fail(1)) SWIG_fail;
26390     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
26391     if (SWIG_arg_fail(2)) SWIG_fail;
26392     {
26393         PyThreadState* __tstate = wxPyBeginAllowThreads();
26394         (arg1)->SetFrame(arg2);
26395
26396         wxPyEndAllowThreads(__tstate);
26397         if (PyErr_Occurred()) SWIG_fail;
26398     }
26399     Py_INCREF(Py_None); resultobj = Py_None;
26400     return resultobj;
26401     fail:
26402     return NULL;
26403 }
26404
26405
26406 static PyObject *_wrap_PrintPreview_SetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26407     PyObject *resultobj;
26408     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26409     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26410     PyObject * obj0 = 0 ;
26411     PyObject * obj1 = 0 ;
26412     char *kwnames[] = {
26413         (char *) "self",(char *) "canvas", NULL
26414     };
26415
26416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCanvas",kwnames,&obj0,&obj1)) goto fail;
26417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26418     if (SWIG_arg_fail(1)) SWIG_fail;
26419     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26420     if (SWIG_arg_fail(2)) SWIG_fail;
26421     {
26422         PyThreadState* __tstate = wxPyBeginAllowThreads();
26423         (arg1)->SetCanvas(arg2);
26424
26425         wxPyEndAllowThreads(__tstate);
26426         if (PyErr_Occurred()) SWIG_fail;
26427     }
26428     Py_INCREF(Py_None); resultobj = Py_None;
26429     return resultobj;
26430     fail:
26431     return NULL;
26432 }
26433
26434
26435 static PyObject *_wrap_PrintPreview_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26436     PyObject *resultobj;
26437     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26438     wxFrame *result;
26439     PyObject * obj0 = 0 ;
26440     char *kwnames[] = {
26441         (char *) "self", NULL
26442     };
26443
26444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetFrame",kwnames,&obj0)) goto fail;
26445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26446     if (SWIG_arg_fail(1)) SWIG_fail;
26447     {
26448         PyThreadState* __tstate = wxPyBeginAllowThreads();
26449         result = (wxFrame *)(arg1)->GetFrame();
26450
26451         wxPyEndAllowThreads(__tstate);
26452         if (PyErr_Occurred()) SWIG_fail;
26453     }
26454     {
26455         resultobj = wxPyMake_wxObject(result, 0);
26456     }
26457     return resultobj;
26458     fail:
26459     return NULL;
26460 }
26461
26462
26463 static PyObject *_wrap_PrintPreview_GetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26464     PyObject *resultobj;
26465     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26466     wxPreviewCanvas *result;
26467     PyObject * obj0 = 0 ;
26468     char *kwnames[] = {
26469         (char *) "self", NULL
26470     };
26471
26472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCanvas",kwnames,&obj0)) goto fail;
26473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26474     if (SWIG_arg_fail(1)) SWIG_fail;
26475     {
26476         PyThreadState* __tstate = wxPyBeginAllowThreads();
26477         result = (wxPreviewCanvas *)(arg1)->GetCanvas();
26478
26479         wxPyEndAllowThreads(__tstate);
26480         if (PyErr_Occurred()) SWIG_fail;
26481     }
26482     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 0);
26483     return resultobj;
26484     fail:
26485     return NULL;
26486 }
26487
26488
26489 static PyObject *_wrap_PrintPreview_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26490     PyObject *resultobj;
26491     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26492     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26493     wxDC *arg3 = 0 ;
26494     bool result;
26495     PyObject * obj0 = 0 ;
26496     PyObject * obj1 = 0 ;
26497     PyObject * obj2 = 0 ;
26498     char *kwnames[] = {
26499         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26500     };
26501
26502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26504     if (SWIG_arg_fail(1)) SWIG_fail;
26505     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26506     if (SWIG_arg_fail(2)) SWIG_fail;
26507     {
26508         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26509         if (SWIG_arg_fail(3)) SWIG_fail;
26510         if (arg3 == NULL) {
26511             SWIG_null_ref("wxDC");
26512         }
26513         if (SWIG_arg_fail(3)) SWIG_fail;
26514     }
26515     {
26516         PyThreadState* __tstate = wxPyBeginAllowThreads();
26517         result = (bool)(arg1)->PaintPage(arg2,*arg3);
26518
26519         wxPyEndAllowThreads(__tstate);
26520         if (PyErr_Occurred()) SWIG_fail;
26521     }
26522     {
26523         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26524     }
26525     return resultobj;
26526     fail:
26527     return NULL;
26528 }
26529
26530
26531 static PyObject *_wrap_PrintPreview_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26532     PyObject *resultobj;
26533     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26534     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26535     wxDC *arg3 = 0 ;
26536     bool result;
26537     PyObject * obj0 = 0 ;
26538     PyObject * obj1 = 0 ;
26539     PyObject * obj2 = 0 ;
26540     char *kwnames[] = {
26541         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26542     };
26543
26544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26546     if (SWIG_arg_fail(1)) SWIG_fail;
26547     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26548     if (SWIG_arg_fail(2)) SWIG_fail;
26549     {
26550         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26551         if (SWIG_arg_fail(3)) SWIG_fail;
26552         if (arg3 == NULL) {
26553             SWIG_null_ref("wxDC");
26554         }
26555         if (SWIG_arg_fail(3)) SWIG_fail;
26556     }
26557     {
26558         PyThreadState* __tstate = wxPyBeginAllowThreads();
26559         result = (bool)(arg1)->DrawBlankPage(arg2,*arg3);
26560
26561         wxPyEndAllowThreads(__tstate);
26562         if (PyErr_Occurred()) SWIG_fail;
26563     }
26564     {
26565         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26566     }
26567     return resultobj;
26568     fail:
26569     return NULL;
26570 }
26571
26572
26573 static PyObject *_wrap_PrintPreview_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
26574     PyObject *resultobj;
26575     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26576     int arg2 ;
26577     bool result;
26578     PyObject * obj0 = 0 ;
26579     PyObject * obj1 = 0 ;
26580     char *kwnames[] = {
26581         (char *) "self",(char *) "pageNum", NULL
26582     };
26583
26584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_RenderPage",kwnames,&obj0,&obj1)) goto fail;
26585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26586     if (SWIG_arg_fail(1)) SWIG_fail;
26587     {
26588         arg2 = (int)(SWIG_As_int(obj1));
26589         if (SWIG_arg_fail(2)) SWIG_fail;
26590     }
26591     {
26592         PyThreadState* __tstate = wxPyBeginAllowThreads();
26593         result = (bool)(arg1)->RenderPage(arg2);
26594
26595         wxPyEndAllowThreads(__tstate);
26596         if (PyErr_Occurred()) SWIG_fail;
26597     }
26598     {
26599         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26600     }
26601     return resultobj;
26602     fail:
26603     return NULL;
26604 }
26605
26606
26607 static PyObject *_wrap_PrintPreview_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
26608     PyObject *resultobj;
26609     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26610     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26611     PyObject * obj0 = 0 ;
26612     PyObject * obj1 = 0 ;
26613     char *kwnames[] = {
26614         (char *) "self",(char *) "canvas", NULL
26615     };
26616
26617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_AdjustScrollbars",kwnames,&obj0,&obj1)) goto fail;
26618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26619     if (SWIG_arg_fail(1)) SWIG_fail;
26620     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26621     if (SWIG_arg_fail(2)) SWIG_fail;
26622     {
26623         PyThreadState* __tstate = wxPyBeginAllowThreads();
26624         (arg1)->AdjustScrollbars(arg2);
26625
26626         wxPyEndAllowThreads(__tstate);
26627         if (PyErr_Occurred()) SWIG_fail;
26628     }
26629     Py_INCREF(Py_None); resultobj = Py_None;
26630     return resultobj;
26631     fail:
26632     return NULL;
26633 }
26634
26635
26636 static PyObject *_wrap_PrintPreview_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
26637     PyObject *resultobj;
26638     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26639     wxPrintDialogData *result;
26640     PyObject * obj0 = 0 ;
26641     char *kwnames[] = {
26642         (char *) "self", NULL
26643     };
26644
26645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintDialogData",kwnames,&obj0)) goto fail;
26646     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26647     if (SWIG_arg_fail(1)) SWIG_fail;
26648     {
26649         PyThreadState* __tstate = wxPyBeginAllowThreads();
26650         {
26651             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
26652             result = (wxPrintDialogData *) &_result_ref;
26653         }
26654
26655         wxPyEndAllowThreads(__tstate);
26656         if (PyErr_Occurred()) SWIG_fail;
26657     }
26658     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
26659     return resultobj;
26660     fail:
26661     return NULL;
26662 }
26663
26664
26665 static PyObject *_wrap_PrintPreview_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26666     PyObject *resultobj;
26667     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26668     int arg2 ;
26669     PyObject * obj0 = 0 ;
26670     PyObject * obj1 = 0 ;
26671     char *kwnames[] = {
26672         (char *) "self",(char *) "percent", NULL
26673     };
26674
26675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetZoom",kwnames,&obj0,&obj1)) goto fail;
26676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26677     if (SWIG_arg_fail(1)) SWIG_fail;
26678     {
26679         arg2 = (int)(SWIG_As_int(obj1));
26680         if (SWIG_arg_fail(2)) SWIG_fail;
26681     }
26682     {
26683         PyThreadState* __tstate = wxPyBeginAllowThreads();
26684         (arg1)->SetZoom(arg2);
26685
26686         wxPyEndAllowThreads(__tstate);
26687         if (PyErr_Occurred()) SWIG_fail;
26688     }
26689     Py_INCREF(Py_None); resultobj = Py_None;
26690     return resultobj;
26691     fail:
26692     return NULL;
26693 }
26694
26695
26696 static PyObject *_wrap_PrintPreview_GetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26697     PyObject *resultobj;
26698     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26699     int result;
26700     PyObject * obj0 = 0 ;
26701     char *kwnames[] = {
26702         (char *) "self", NULL
26703     };
26704
26705     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetZoom",kwnames,&obj0)) goto fail;
26706     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26707     if (SWIG_arg_fail(1)) SWIG_fail;
26708     {
26709         PyThreadState* __tstate = wxPyBeginAllowThreads();
26710         result = (int)(arg1)->GetZoom();
26711
26712         wxPyEndAllowThreads(__tstate);
26713         if (PyErr_Occurred()) SWIG_fail;
26714     }
26715     {
26716         resultobj = SWIG_From_int((int)(result));
26717     }
26718     return resultobj;
26719     fail:
26720     return NULL;
26721 }
26722
26723
26724 static PyObject *_wrap_PrintPreview_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
26725     PyObject *resultobj;
26726     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26727     int result;
26728     PyObject * obj0 = 0 ;
26729     char *kwnames[] = {
26730         (char *) "self", NULL
26731     };
26732
26733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMaxPage",kwnames,&obj0)) goto fail;
26734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26735     if (SWIG_arg_fail(1)) SWIG_fail;
26736     {
26737         PyThreadState* __tstate = wxPyBeginAllowThreads();
26738         result = (int)(arg1)->GetMaxPage();
26739
26740         wxPyEndAllowThreads(__tstate);
26741         if (PyErr_Occurred()) SWIG_fail;
26742     }
26743     {
26744         resultobj = SWIG_From_int((int)(result));
26745     }
26746     return resultobj;
26747     fail:
26748     return NULL;
26749 }
26750
26751
26752 static PyObject *_wrap_PrintPreview_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
26753     PyObject *resultobj;
26754     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26755     int result;
26756     PyObject * obj0 = 0 ;
26757     char *kwnames[] = {
26758         (char *) "self", NULL
26759     };
26760
26761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMinPage",kwnames,&obj0)) goto fail;
26762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26763     if (SWIG_arg_fail(1)) SWIG_fail;
26764     {
26765         PyThreadState* __tstate = wxPyBeginAllowThreads();
26766         result = (int)(arg1)->GetMinPage();
26767
26768         wxPyEndAllowThreads(__tstate);
26769         if (PyErr_Occurred()) SWIG_fail;
26770     }
26771     {
26772         resultobj = SWIG_From_int((int)(result));
26773     }
26774     return resultobj;
26775     fail:
26776     return NULL;
26777 }
26778
26779
26780 static PyObject *_wrap_PrintPreview_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
26781     PyObject *resultobj;
26782     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26783     bool result;
26784     PyObject * obj0 = 0 ;
26785     char *kwnames[] = {
26786         (char *) "self", NULL
26787     };
26788
26789     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_Ok",kwnames,&obj0)) goto fail;
26790     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26791     if (SWIG_arg_fail(1)) SWIG_fail;
26792     {
26793         PyThreadState* __tstate = wxPyBeginAllowThreads();
26794         result = (bool)(arg1)->Ok();
26795
26796         wxPyEndAllowThreads(__tstate);
26797         if (PyErr_Occurred()) SWIG_fail;
26798     }
26799     {
26800         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26801     }
26802     return resultobj;
26803     fail:
26804     return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_PrintPreview_SetOk(PyObject *, PyObject *args, PyObject *kwargs) {
26809     PyObject *resultobj;
26810     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26811     bool arg2 ;
26812     PyObject * obj0 = 0 ;
26813     PyObject * obj1 = 0 ;
26814     char *kwnames[] = {
26815         (char *) "self",(char *) "ok", NULL
26816     };
26817
26818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetOk",kwnames,&obj0,&obj1)) goto fail;
26819     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26820     if (SWIG_arg_fail(1)) SWIG_fail;
26821     {
26822         arg2 = (bool)(SWIG_As_bool(obj1));
26823         if (SWIG_arg_fail(2)) SWIG_fail;
26824     }
26825     {
26826         PyThreadState* __tstate = wxPyBeginAllowThreads();
26827         (arg1)->SetOk(arg2);
26828
26829         wxPyEndAllowThreads(__tstate);
26830         if (PyErr_Occurred()) SWIG_fail;
26831     }
26832     Py_INCREF(Py_None); resultobj = Py_None;
26833     return resultobj;
26834     fail:
26835     return NULL;
26836 }
26837
26838
26839 static PyObject *_wrap_PrintPreview_Print(PyObject *, PyObject *args, PyObject *kwargs) {
26840     PyObject *resultobj;
26841     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26842     bool arg2 ;
26843     bool result;
26844     PyObject * obj0 = 0 ;
26845     PyObject * obj1 = 0 ;
26846     char *kwnames[] = {
26847         (char *) "self",(char *) "interactive", NULL
26848     };
26849
26850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_Print",kwnames,&obj0,&obj1)) goto fail;
26851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26852     if (SWIG_arg_fail(1)) SWIG_fail;
26853     {
26854         arg2 = (bool)(SWIG_As_bool(obj1));
26855         if (SWIG_arg_fail(2)) SWIG_fail;
26856     }
26857     {
26858         PyThreadState* __tstate = wxPyBeginAllowThreads();
26859         result = (bool)(arg1)->Print(arg2);
26860
26861         wxPyEndAllowThreads(__tstate);
26862         if (PyErr_Occurred()) SWIG_fail;
26863     }
26864     {
26865         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26866     }
26867     return resultobj;
26868     fail:
26869     return NULL;
26870 }
26871
26872
26873 static PyObject *_wrap_PrintPreview_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
26874     PyObject *resultobj;
26875     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26876     PyObject * obj0 = 0 ;
26877     char *kwnames[] = {
26878         (char *) "self", NULL
26879     };
26880
26881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_DetermineScaling",kwnames,&obj0)) goto fail;
26882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26883     if (SWIG_arg_fail(1)) SWIG_fail;
26884     {
26885         PyThreadState* __tstate = wxPyBeginAllowThreads();
26886         (arg1)->DetermineScaling();
26887
26888         wxPyEndAllowThreads(__tstate);
26889         if (PyErr_Occurred()) SWIG_fail;
26890     }
26891     Py_INCREF(Py_None); resultobj = Py_None;
26892     return resultobj;
26893     fail:
26894     return NULL;
26895 }
26896
26897
26898 static PyObject * PrintPreview_swigregister(PyObject *, PyObject *args) {
26899     PyObject *obj;
26900     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26901     SWIG_TypeClientData(SWIGTYPE_p_wxPrintPreview, obj);
26902     Py_INCREF(obj);
26903     return Py_BuildValue((char *)"");
26904 }
26905 static PyObject *_wrap_new_PyPrintPreview__SWIG_0(PyObject *, PyObject *args) {
26906     PyObject *resultobj;
26907     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26908     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26909     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26910     wxPyPrintPreview *result;
26911     PyObject * obj0 = 0 ;
26912     PyObject * obj1 = 0 ;
26913     PyObject * obj2 = 0 ;
26914
26915     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26917     if (SWIG_arg_fail(1)) SWIG_fail;
26918     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26919     if (SWIG_arg_fail(2)) SWIG_fail;
26920     if (obj2) {
26921         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26922         if (SWIG_arg_fail(3)) SWIG_fail;
26923     }
26924     {
26925         if (!wxPyCheckForApp()) SWIG_fail;
26926         PyThreadState* __tstate = wxPyBeginAllowThreads();
26927         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26928
26929         wxPyEndAllowThreads(__tstate);
26930         if (PyErr_Occurred()) SWIG_fail;
26931     }
26932     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26933     return resultobj;
26934     fail:
26935     return NULL;
26936 }
26937
26938
26939 static PyObject *_wrap_new_PyPrintPreview__SWIG_1(PyObject *, PyObject *args) {
26940     PyObject *resultobj;
26941     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26942     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26943     wxPrintData *arg3 = (wxPrintData *) 0 ;
26944     wxPyPrintPreview *result;
26945     PyObject * obj0 = 0 ;
26946     PyObject * obj1 = 0 ;
26947     PyObject * obj2 = 0 ;
26948
26949     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26951     if (SWIG_arg_fail(1)) SWIG_fail;
26952     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26953     if (SWIG_arg_fail(2)) SWIG_fail;
26954     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26955     if (SWIG_arg_fail(3)) SWIG_fail;
26956     {
26957         if (!wxPyCheckForApp()) SWIG_fail;
26958         PyThreadState* __tstate = wxPyBeginAllowThreads();
26959         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26960
26961         wxPyEndAllowThreads(__tstate);
26962         if (PyErr_Occurred()) SWIG_fail;
26963     }
26964     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26965     return resultobj;
26966     fail:
26967     return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_new_PyPrintPreview(PyObject *self, PyObject *args) {
26972     int argc;
26973     PyObject *argv[4];
26974     int ii;
26975
26976     argc = PyObject_Length(args);
26977     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26978         argv[ii] = PyTuple_GetItem(args,ii);
26979     }
26980     if ((argc >= 2) && (argc <= 3)) {
26981         int _v;
26982         {
26983             void *ptr;
26984             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26985                 _v = 0;
26986                 PyErr_Clear();
26987             } else {
26988                 _v = 1;
26989             }
26990         }
26991         if (_v) {
26992             {
26993                 void *ptr;
26994                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26995                     _v = 0;
26996                     PyErr_Clear();
26997                 } else {
26998                     _v = 1;
26999                 }
27000             }
27001             if (_v) {
27002                 if (argc <= 2) {
27003                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
27004                 }
27005                 {
27006                     void *ptr;
27007                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
27008                         _v = 0;
27009                         PyErr_Clear();
27010                     } else {
27011                         _v = 1;
27012                     }
27013                 }
27014                 if (_v) {
27015                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
27016                 }
27017             }
27018         }
27019     }
27020     if (argc == 3) {
27021         int _v;
27022         {
27023             void *ptr;
27024             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
27025                 _v = 0;
27026                 PyErr_Clear();
27027             } else {
27028                 _v = 1;
27029             }
27030         }
27031         if (_v) {
27032             {
27033                 void *ptr;
27034                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
27035                     _v = 0;
27036                     PyErr_Clear();
27037                 } else {
27038                     _v = 1;
27039                 }
27040             }
27041             if (_v) {
27042                 {
27043                     void *ptr;
27044                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
27045                         _v = 0;
27046                         PyErr_Clear();
27047                     } else {
27048                         _v = 1;
27049                     }
27050                 }
27051                 if (_v) {
27052                     return _wrap_new_PyPrintPreview__SWIG_1(self,args);
27053                 }
27054             }
27055         }
27056     }
27057
27058     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PyPrintPreview'");
27059     return NULL;
27060 }
27061
27062
27063 static PyObject *_wrap_PyPrintPreview__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27064     PyObject *resultobj;
27065     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27066     PyObject *arg2 = (PyObject *) 0 ;
27067     PyObject *arg3 = (PyObject *) 0 ;
27068     PyObject * obj0 = 0 ;
27069     PyObject * obj1 = 0 ;
27070     PyObject * obj2 = 0 ;
27071     char *kwnames[] = {
27072         (char *) "self",(char *) "self",(char *) "_class", NULL
27073     };
27074
27075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27076     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27077     if (SWIG_arg_fail(1)) SWIG_fail;
27078     arg2 = obj1;
27079     arg3 = obj2;
27080     {
27081         PyThreadState* __tstate = wxPyBeginAllowThreads();
27082         (arg1)->_setCallbackInfo(arg2,arg3);
27083
27084         wxPyEndAllowThreads(__tstate);
27085         if (PyErr_Occurred()) SWIG_fail;
27086     }
27087     Py_INCREF(Py_None); resultobj = Py_None;
27088     return resultobj;
27089     fail:
27090     return NULL;
27091 }
27092
27093
27094 static PyObject *_wrap_PyPrintPreview_base_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
27095     PyObject *resultobj;
27096     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27097     int arg2 ;
27098     bool result;
27099     PyObject * obj0 = 0 ;
27100     PyObject * obj1 = 0 ;
27101     char *kwnames[] = {
27102         (char *) "self",(char *) "pageNum", NULL
27103     };
27104
27105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
27106     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27107     if (SWIG_arg_fail(1)) SWIG_fail;
27108     {
27109         arg2 = (int)(SWIG_As_int(obj1));
27110         if (SWIG_arg_fail(2)) SWIG_fail;
27111     }
27112     {
27113         PyThreadState* __tstate = wxPyBeginAllowThreads();
27114         result = (bool)(arg1)->base_SetCurrentPage(arg2);
27115
27116         wxPyEndAllowThreads(__tstate);
27117         if (PyErr_Occurred()) SWIG_fail;
27118     }
27119     {
27120         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27121     }
27122     return resultobj;
27123     fail:
27124     return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_PyPrintPreview_base_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
27129     PyObject *resultobj;
27130     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27131     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27132     wxDC *arg3 = 0 ;
27133     bool result;
27134     PyObject * obj0 = 0 ;
27135     PyObject * obj1 = 0 ;
27136     PyObject * obj2 = 0 ;
27137     char *kwnames[] = {
27138         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27139     };
27140
27141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27143     if (SWIG_arg_fail(1)) SWIG_fail;
27144     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27145     if (SWIG_arg_fail(2)) SWIG_fail;
27146     {
27147         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27148         if (SWIG_arg_fail(3)) SWIG_fail;
27149         if (arg3 == NULL) {
27150             SWIG_null_ref("wxDC");
27151         }
27152         if (SWIG_arg_fail(3)) SWIG_fail;
27153     }
27154     {
27155         PyThreadState* __tstate = wxPyBeginAllowThreads();
27156         result = (bool)(arg1)->base_PaintPage(arg2,*arg3);
27157
27158         wxPyEndAllowThreads(__tstate);
27159         if (PyErr_Occurred()) SWIG_fail;
27160     }
27161     {
27162         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27163     }
27164     return resultobj;
27165     fail:
27166     return NULL;
27167 }
27168
27169
27170 static PyObject *_wrap_PyPrintPreview_base_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
27171     PyObject *resultobj;
27172     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27173     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27174     wxDC *arg3 = 0 ;
27175     bool result;
27176     PyObject * obj0 = 0 ;
27177     PyObject * obj1 = 0 ;
27178     PyObject * obj2 = 0 ;
27179     char *kwnames[] = {
27180         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27181     };
27182
27183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27185     if (SWIG_arg_fail(1)) SWIG_fail;
27186     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27187     if (SWIG_arg_fail(2)) SWIG_fail;
27188     {
27189         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27190         if (SWIG_arg_fail(3)) SWIG_fail;
27191         if (arg3 == NULL) {
27192             SWIG_null_ref("wxDC");
27193         }
27194         if (SWIG_arg_fail(3)) SWIG_fail;
27195     }
27196     {
27197         PyThreadState* __tstate = wxPyBeginAllowThreads();
27198         result = (bool)(arg1)->base_DrawBlankPage(arg2,*arg3);
27199
27200         wxPyEndAllowThreads(__tstate);
27201         if (PyErr_Occurred()) SWIG_fail;
27202     }
27203     {
27204         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27205     }
27206     return resultobj;
27207     fail:
27208     return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_PyPrintPreview_base_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
27213     PyObject *resultobj;
27214     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27215     int arg2 ;
27216     bool result;
27217     PyObject * obj0 = 0 ;
27218     PyObject * obj1 = 0 ;
27219     char *kwnames[] = {
27220         (char *) "self",(char *) "pageNum", NULL
27221     };
27222
27223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_RenderPage",kwnames,&obj0,&obj1)) goto fail;
27224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27225     if (SWIG_arg_fail(1)) SWIG_fail;
27226     {
27227         arg2 = (int)(SWIG_As_int(obj1));
27228         if (SWIG_arg_fail(2)) SWIG_fail;
27229     }
27230     {
27231         PyThreadState* __tstate = wxPyBeginAllowThreads();
27232         result = (bool)(arg1)->base_RenderPage(arg2);
27233
27234         wxPyEndAllowThreads(__tstate);
27235         if (PyErr_Occurred()) SWIG_fail;
27236     }
27237     {
27238         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27239     }
27240     return resultobj;
27241     fail:
27242     return NULL;
27243 }
27244
27245
27246 static PyObject *_wrap_PyPrintPreview_base_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
27247     PyObject *resultobj;
27248     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27249     int arg2 ;
27250     PyObject * obj0 = 0 ;
27251     PyObject * obj1 = 0 ;
27252     char *kwnames[] = {
27253         (char *) "self",(char *) "percent", NULL
27254     };
27255
27256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetZoom",kwnames,&obj0,&obj1)) goto fail;
27257     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27258     if (SWIG_arg_fail(1)) SWIG_fail;
27259     {
27260         arg2 = (int)(SWIG_As_int(obj1));
27261         if (SWIG_arg_fail(2)) SWIG_fail;
27262     }
27263     {
27264         PyThreadState* __tstate = wxPyBeginAllowThreads();
27265         (arg1)->base_SetZoom(arg2);
27266
27267         wxPyEndAllowThreads(__tstate);
27268         if (PyErr_Occurred()) SWIG_fail;
27269     }
27270     Py_INCREF(Py_None); resultobj = Py_None;
27271     return resultobj;
27272     fail:
27273     return NULL;
27274 }
27275
27276
27277 static PyObject *_wrap_PyPrintPreview_base_Print(PyObject *, PyObject *args, PyObject *kwargs) {
27278     PyObject *resultobj;
27279     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27280     bool arg2 ;
27281     bool result;
27282     PyObject * obj0 = 0 ;
27283     PyObject * obj1 = 0 ;
27284     char *kwnames[] = {
27285         (char *) "self",(char *) "interactive", NULL
27286     };
27287
27288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_Print",kwnames,&obj0,&obj1)) goto fail;
27289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27290     if (SWIG_arg_fail(1)) SWIG_fail;
27291     {
27292         arg2 = (bool)(SWIG_As_bool(obj1));
27293         if (SWIG_arg_fail(2)) SWIG_fail;
27294     }
27295     {
27296         PyThreadState* __tstate = wxPyBeginAllowThreads();
27297         result = (bool)(arg1)->base_Print(arg2);
27298
27299         wxPyEndAllowThreads(__tstate);
27300         if (PyErr_Occurred()) SWIG_fail;
27301     }
27302     {
27303         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27304     }
27305     return resultobj;
27306     fail:
27307     return NULL;
27308 }
27309
27310
27311 static PyObject *_wrap_PyPrintPreview_base_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
27312     PyObject *resultobj;
27313     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27314     PyObject * obj0 = 0 ;
27315     char *kwnames[] = {
27316         (char *) "self", NULL
27317     };
27318
27319     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPrintPreview_base_DetermineScaling",kwnames,&obj0)) goto fail;
27320     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27321     if (SWIG_arg_fail(1)) SWIG_fail;
27322     {
27323         PyThreadState* __tstate = wxPyBeginAllowThreads();
27324         (arg1)->base_DetermineScaling();
27325
27326         wxPyEndAllowThreads(__tstate);
27327         if (PyErr_Occurred()) SWIG_fail;
27328     }
27329     Py_INCREF(Py_None); resultobj = Py_None;
27330     return resultobj;
27331     fail:
27332     return NULL;
27333 }
27334
27335
27336 static PyObject * PyPrintPreview_swigregister(PyObject *, PyObject *args) {
27337     PyObject *obj;
27338     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27339     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintPreview, obj);
27340     Py_INCREF(obj);
27341     return Py_BuildValue((char *)"");
27342 }
27343 static PyObject *_wrap_new_PyPreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
27344     PyObject *resultobj;
27345     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27346     wxFrame *arg2 = (wxFrame *) 0 ;
27347     wxString *arg3 = 0 ;
27348     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27349     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27350     wxSize const &arg5_defvalue = wxDefaultSize ;
27351     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27352     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
27353     wxString const &arg7_defvalue = wxPyFrameNameStr ;
27354     wxString *arg7 = (wxString *) &arg7_defvalue ;
27355     wxPyPreviewFrame *result;
27356     bool temp3 = false ;
27357     wxPoint temp4 ;
27358     wxSize temp5 ;
27359     bool temp7 = false ;
27360     PyObject * obj0 = 0 ;
27361     PyObject * obj1 = 0 ;
27362     PyObject * obj2 = 0 ;
27363     PyObject * obj3 = 0 ;
27364     PyObject * obj4 = 0 ;
27365     PyObject * obj5 = 0 ;
27366     PyObject * obj6 = 0 ;
27367     char *kwnames[] = {
27368         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27369     };
27370
27371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27372     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27373     if (SWIG_arg_fail(1)) SWIG_fail;
27374     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
27375     if (SWIG_arg_fail(2)) SWIG_fail;
27376     {
27377         arg3 = wxString_in_helper(obj2);
27378         if (arg3 == NULL) SWIG_fail;
27379         temp3 = true;
27380     }
27381     if (obj3) {
27382         {
27383             arg4 = &temp4;
27384             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27385         }
27386     }
27387     if (obj4) {
27388         {
27389             arg5 = &temp5;
27390             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27391         }
27392     }
27393     if (obj5) {
27394         {
27395             arg6 = (long)(SWIG_As_long(obj5));
27396             if (SWIG_arg_fail(6)) SWIG_fail;
27397         }
27398     }
27399     if (obj6) {
27400         {
27401             arg7 = wxString_in_helper(obj6);
27402             if (arg7 == NULL) SWIG_fail;
27403             temp7 = true;
27404         }
27405     }
27406     {
27407         if (!wxPyCheckForApp()) SWIG_fail;
27408         PyThreadState* __tstate = wxPyBeginAllowThreads();
27409         result = (wxPyPreviewFrame *)new wxPyPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27410
27411         wxPyEndAllowThreads(__tstate);
27412         if (PyErr_Occurred()) SWIG_fail;
27413     }
27414     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewFrame, 1);
27415     {
27416         if (temp3)
27417         delete arg3;
27418     }
27419     {
27420         if (temp7)
27421         delete arg7;
27422     }
27423     return resultobj;
27424     fail:
27425     {
27426         if (temp3)
27427         delete arg3;
27428     }
27429     {
27430         if (temp7)
27431         delete arg7;
27432     }
27433     return NULL;
27434 }
27435
27436
27437 static PyObject *_wrap_PyPreviewFrame__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27438     PyObject *resultobj;
27439     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27440     PyObject *arg2 = (PyObject *) 0 ;
27441     PyObject *arg3 = (PyObject *) 0 ;
27442     PyObject * obj0 = 0 ;
27443     PyObject * obj1 = 0 ;
27444     PyObject * obj2 = 0 ;
27445     char *kwnames[] = {
27446         (char *) "self",(char *) "self",(char *) "_class", NULL
27447     };
27448
27449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewFrame__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27451     if (SWIG_arg_fail(1)) SWIG_fail;
27452     arg2 = obj1;
27453     arg3 = obj2;
27454     {
27455         PyThreadState* __tstate = wxPyBeginAllowThreads();
27456         (arg1)->_setCallbackInfo(arg2,arg3);
27457
27458         wxPyEndAllowThreads(__tstate);
27459         if (PyErr_Occurred()) SWIG_fail;
27460     }
27461     Py_INCREF(Py_None); resultobj = Py_None;
27462     return resultobj;
27463     fail:
27464     return NULL;
27465 }
27466
27467
27468 static PyObject *_wrap_PyPreviewFrame_SetPreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27469     PyObject *resultobj;
27470     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27471     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27472     PyObject * obj0 = 0 ;
27473     PyObject * obj1 = 0 ;
27474     char *kwnames[] = {
27475         (char *) "self",(char *) "canvas", NULL
27476     };
27477
27478     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetPreviewCanvas",kwnames,&obj0,&obj1)) goto fail;
27479     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27480     if (SWIG_arg_fail(1)) SWIG_fail;
27481     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27482     if (SWIG_arg_fail(2)) SWIG_fail;
27483     {
27484         PyThreadState* __tstate = wxPyBeginAllowThreads();
27485         (arg1)->SetPreviewCanvas(arg2);
27486
27487         wxPyEndAllowThreads(__tstate);
27488         if (PyErr_Occurred()) SWIG_fail;
27489     }
27490     Py_INCREF(Py_None); resultobj = Py_None;
27491     return resultobj;
27492     fail:
27493     return NULL;
27494 }
27495
27496
27497 static PyObject *_wrap_PyPreviewFrame_SetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27498     PyObject *resultobj;
27499     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27500     wxPreviewControlBar *arg2 = (wxPreviewControlBar *) 0 ;
27501     PyObject * obj0 = 0 ;
27502     PyObject * obj1 = 0 ;
27503     char *kwnames[] = {
27504         (char *) "self",(char *) "bar", NULL
27505     };
27506
27507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetControlBar",kwnames,&obj0,&obj1)) goto fail;
27508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27509     if (SWIG_arg_fail(1)) SWIG_fail;
27510     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27511     if (SWIG_arg_fail(2)) SWIG_fail;
27512     {
27513         PyThreadState* __tstate = wxPyBeginAllowThreads();
27514         (arg1)->SetControlBar(arg2);
27515
27516         wxPyEndAllowThreads(__tstate);
27517         if (PyErr_Occurred()) SWIG_fail;
27518     }
27519     Py_INCREF(Py_None); resultobj = Py_None;
27520     return resultobj;
27521     fail:
27522     return NULL;
27523 }
27524
27525
27526 static PyObject *_wrap_PyPreviewFrame_base_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
27527     PyObject *resultobj;
27528     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27529     PyObject * obj0 = 0 ;
27530     char *kwnames[] = {
27531         (char *) "self", NULL
27532     };
27533
27534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_Initialize",kwnames,&obj0)) goto fail;
27535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27536     if (SWIG_arg_fail(1)) SWIG_fail;
27537     {
27538         PyThreadState* __tstate = wxPyBeginAllowThreads();
27539         (arg1)->base_Initialize();
27540
27541         wxPyEndAllowThreads(__tstate);
27542         if (PyErr_Occurred()) SWIG_fail;
27543     }
27544     Py_INCREF(Py_None); resultobj = Py_None;
27545     return resultobj;
27546     fail:
27547     return NULL;
27548 }
27549
27550
27551 static PyObject *_wrap_PyPreviewFrame_base_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27552     PyObject *resultobj;
27553     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27554     PyObject * obj0 = 0 ;
27555     char *kwnames[] = {
27556         (char *) "self", NULL
27557     };
27558
27559     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateCanvas",kwnames,&obj0)) goto fail;
27560     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27561     if (SWIG_arg_fail(1)) SWIG_fail;
27562     {
27563         PyThreadState* __tstate = wxPyBeginAllowThreads();
27564         (arg1)->base_CreateCanvas();
27565
27566         wxPyEndAllowThreads(__tstate);
27567         if (PyErr_Occurred()) SWIG_fail;
27568     }
27569     Py_INCREF(Py_None); resultobj = Py_None;
27570     return resultobj;
27571     fail:
27572     return NULL;
27573 }
27574
27575
27576 static PyObject *_wrap_PyPreviewFrame_base_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27577     PyObject *resultobj;
27578     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27579     PyObject * obj0 = 0 ;
27580     char *kwnames[] = {
27581         (char *) "self", NULL
27582     };
27583
27584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateControlBar",kwnames,&obj0)) goto fail;
27585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27586     if (SWIG_arg_fail(1)) SWIG_fail;
27587     {
27588         PyThreadState* __tstate = wxPyBeginAllowThreads();
27589         (arg1)->base_CreateControlBar();
27590
27591         wxPyEndAllowThreads(__tstate);
27592         if (PyErr_Occurred()) SWIG_fail;
27593     }
27594     Py_INCREF(Py_None); resultobj = Py_None;
27595     return resultobj;
27596     fail:
27597     return NULL;
27598 }
27599
27600
27601 static PyObject * PyPreviewFrame_swigregister(PyObject *, PyObject *args) {
27602     PyObject *obj;
27603     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27604     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewFrame, obj);
27605     Py_INCREF(obj);
27606     return Py_BuildValue((char *)"");
27607 }
27608 static PyObject *_wrap_new_PyPreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27609     PyObject *resultobj;
27610     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27611     long arg2 ;
27612     wxWindow *arg3 = (wxWindow *) 0 ;
27613     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27614     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27615     wxSize const &arg5_defvalue = wxDefaultSize ;
27616     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27617     long arg6 = (long) 0 ;
27618     wxString const &arg7_defvalue = wxPyPanelNameStr ;
27619     wxString *arg7 = (wxString *) &arg7_defvalue ;
27620     wxPyPreviewControlBar *result;
27621     wxPoint temp4 ;
27622     wxSize temp5 ;
27623     bool temp7 = false ;
27624     PyObject * obj0 = 0 ;
27625     PyObject * obj1 = 0 ;
27626     PyObject * obj2 = 0 ;
27627     PyObject * obj3 = 0 ;
27628     PyObject * obj4 = 0 ;
27629     PyObject * obj5 = 0 ;
27630     PyObject * obj6 = 0 ;
27631     char *kwnames[] = {
27632         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27633     };
27634
27635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27637     if (SWIG_arg_fail(1)) SWIG_fail;
27638     {
27639         arg2 = (long)(SWIG_As_long(obj1));
27640         if (SWIG_arg_fail(2)) SWIG_fail;
27641     }
27642     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643     if (SWIG_arg_fail(3)) SWIG_fail;
27644     if (obj3) {
27645         {
27646             arg4 = &temp4;
27647             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27648         }
27649     }
27650     if (obj4) {
27651         {
27652             arg5 = &temp5;
27653             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27654         }
27655     }
27656     if (obj5) {
27657         {
27658             arg6 = (long)(SWIG_As_long(obj5));
27659             if (SWIG_arg_fail(6)) SWIG_fail;
27660         }
27661     }
27662     if (obj6) {
27663         {
27664             arg7 = wxString_in_helper(obj6);
27665             if (arg7 == NULL) SWIG_fail;
27666             temp7 = true;
27667         }
27668     }
27669     {
27670         if (!wxPyCheckForApp()) SWIG_fail;
27671         PyThreadState* __tstate = wxPyBeginAllowThreads();
27672         result = (wxPyPreviewControlBar *)new wxPyPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27673
27674         wxPyEndAllowThreads(__tstate);
27675         if (PyErr_Occurred()) SWIG_fail;
27676     }
27677     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewControlBar, 1);
27678     {
27679         if (temp7)
27680         delete arg7;
27681     }
27682     return resultobj;
27683     fail:
27684     {
27685         if (temp7)
27686         delete arg7;
27687     }
27688     return NULL;
27689 }
27690
27691
27692 static PyObject *_wrap_PyPreviewControlBar__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27693     PyObject *resultobj;
27694     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27695     PyObject *arg2 = (PyObject *) 0 ;
27696     PyObject *arg3 = (PyObject *) 0 ;
27697     PyObject * obj0 = 0 ;
27698     PyObject * obj1 = 0 ;
27699     PyObject * obj2 = 0 ;
27700     char *kwnames[] = {
27701         (char *) "self",(char *) "self",(char *) "_class", NULL
27702     };
27703
27704     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewControlBar__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27705     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27706     if (SWIG_arg_fail(1)) SWIG_fail;
27707     arg2 = obj1;
27708     arg3 = obj2;
27709     {
27710         PyThreadState* __tstate = wxPyBeginAllowThreads();
27711         (arg1)->_setCallbackInfo(arg2,arg3);
27712
27713         wxPyEndAllowThreads(__tstate);
27714         if (PyErr_Occurred()) SWIG_fail;
27715     }
27716     Py_INCREF(Py_None); resultobj = Py_None;
27717     return resultobj;
27718     fail:
27719     return NULL;
27720 }
27721
27722
27723 static PyObject *_wrap_PyPreviewControlBar_SetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
27724     PyObject *resultobj;
27725     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27726     wxPrintPreview *arg2 = (wxPrintPreview *) 0 ;
27727     PyObject * obj0 = 0 ;
27728     PyObject * obj1 = 0 ;
27729     char *kwnames[] = {
27730         (char *) "self",(char *) "preview", NULL
27731     };
27732
27733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_SetPrintPreview",kwnames,&obj0,&obj1)) goto fail;
27734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27735     if (SWIG_arg_fail(1)) SWIG_fail;
27736     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27737     if (SWIG_arg_fail(2)) SWIG_fail;
27738     {
27739         PyThreadState* __tstate = wxPyBeginAllowThreads();
27740         (arg1)->SetPrintPreview(arg2);
27741
27742         wxPyEndAllowThreads(__tstate);
27743         if (PyErr_Occurred()) SWIG_fail;
27744     }
27745     Py_INCREF(Py_None); resultobj = Py_None;
27746     return resultobj;
27747     fail:
27748     return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_PyPreviewControlBar_base_CreateButtons(PyObject *, PyObject *args, PyObject *kwargs) {
27753     PyObject *resultobj;
27754     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27755     PyObject * obj0 = 0 ;
27756     char *kwnames[] = {
27757         (char *) "self", NULL
27758     };
27759
27760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewControlBar_base_CreateButtons",kwnames,&obj0)) goto fail;
27761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27762     if (SWIG_arg_fail(1)) SWIG_fail;
27763     {
27764         PyThreadState* __tstate = wxPyBeginAllowThreads();
27765         (arg1)->base_CreateButtons();
27766
27767         wxPyEndAllowThreads(__tstate);
27768         if (PyErr_Occurred()) SWIG_fail;
27769     }
27770     Py_INCREF(Py_None); resultobj = Py_None;
27771     return resultobj;
27772     fail:
27773     return NULL;
27774 }
27775
27776
27777 static PyObject *_wrap_PyPreviewControlBar_base_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
27778     PyObject *resultobj;
27779     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27780     int arg2 ;
27781     PyObject * obj0 = 0 ;
27782     PyObject * obj1 = 0 ;
27783     char *kwnames[] = {
27784         (char *) "self",(char *) "zoom", NULL
27785     };
27786
27787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_base_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
27788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27789     if (SWIG_arg_fail(1)) SWIG_fail;
27790     {
27791         arg2 = (int)(SWIG_As_int(obj1));
27792         if (SWIG_arg_fail(2)) SWIG_fail;
27793     }
27794     {
27795         PyThreadState* __tstate = wxPyBeginAllowThreads();
27796         (arg1)->base_SetZoomControl(arg2);
27797
27798         wxPyEndAllowThreads(__tstate);
27799         if (PyErr_Occurred()) SWIG_fail;
27800     }
27801     Py_INCREF(Py_None); resultobj = Py_None;
27802     return resultobj;
27803     fail:
27804     return NULL;
27805 }
27806
27807
27808 static PyObject * PyPreviewControlBar_swigregister(PyObject *, PyObject *args) {
27809     PyObject *obj;
27810     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27811     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewControlBar, obj);
27812     Py_INCREF(obj);
27813     return Py_BuildValue((char *)"");
27814 }
27815 static PyMethodDef SwigMethods[] = {
27816          { (char *)"new_Panel", (PyCFunction) _wrap_new_Panel, METH_VARARGS | METH_KEYWORDS, NULL},
27817          { (char *)"new_PrePanel", (PyCFunction) _wrap_new_PrePanel, METH_VARARGS | METH_KEYWORDS, NULL},
27818          { (char *)"Panel_Create", (PyCFunction) _wrap_Panel_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27819          { (char *)"Panel_InitDialog", (PyCFunction) _wrap_Panel_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27820          { (char *)"Panel_SetFocus", (PyCFunction) _wrap_Panel_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
27821          { (char *)"Panel_SetFocusIgnoringChildren", (PyCFunction) _wrap_Panel_SetFocusIgnoringChildren, METH_VARARGS | METH_KEYWORDS, NULL},
27822          { (char *)"Panel_GetClassDefaultAttributes", (PyCFunction) _wrap_Panel_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27823          { (char *)"Panel_swigregister", Panel_swigregister, METH_VARARGS, NULL},
27824          { (char *)"new_ScrolledWindow", (PyCFunction) _wrap_new_ScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27825          { (char *)"new_PreScrolledWindow", (PyCFunction) _wrap_new_PreScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27826          { (char *)"ScrolledWindow_Create", (PyCFunction) _wrap_ScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27827          { (char *)"ScrolledWindow_SetScrollbars", (PyCFunction) _wrap_ScrolledWindow_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27828          { (char *)"ScrolledWindow_Scroll", (PyCFunction) _wrap_ScrolledWindow_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},
27829          { (char *)"ScrolledWindow_GetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27830          { (char *)"ScrolledWindow_SetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27831          { (char *)"ScrolledWindow_SetScrollRate", (PyCFunction) _wrap_ScrolledWindow_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},
27832          { (char *)"ScrolledWindow_GetScrollPixelsPerUnit", (PyCFunction) _wrap_ScrolledWindow_GetScrollPixelsPerUnit, METH_VARARGS | METH_KEYWORDS, NULL},
27833          { (char *)"ScrolledWindow_EnableScrolling", (PyCFunction) _wrap_ScrolledWindow_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},
27834          { (char *)"ScrolledWindow_GetViewStart", (PyCFunction) _wrap_ScrolledWindow_GetViewStart, METH_VARARGS | METH_KEYWORDS, NULL},
27835          { (char *)"ScrolledWindow_SetScale", (PyCFunction) _wrap_ScrolledWindow_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},
27836          { (char *)"ScrolledWindow_GetScaleX", (PyCFunction) _wrap_ScrolledWindow_GetScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
27837          { (char *)"ScrolledWindow_GetScaleY", (PyCFunction) _wrap_ScrolledWindow_GetScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
27838          { (char *)"ScrolledWindow_CalcScrolledPosition", _wrap_ScrolledWindow_CalcScrolledPosition, METH_VARARGS, NULL},
27839          { (char *)"ScrolledWindow_CalcUnscrolledPosition", _wrap_ScrolledWindow_CalcUnscrolledPosition, METH_VARARGS, NULL},
27840          { (char *)"ScrolledWindow_AdjustScrollbars", (PyCFunction) _wrap_ScrolledWindow_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27841          { (char *)"ScrolledWindow_CalcScrollInc", (PyCFunction) _wrap_ScrolledWindow_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},
27842          { (char *)"ScrolledWindow_SetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27843          { (char *)"ScrolledWindow_GetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_GetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27844          { (char *)"ScrolledWindow_SetTargetRect", (PyCFunction) _wrap_ScrolledWindow_SetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27845          { (char *)"ScrolledWindow_GetTargetRect", (PyCFunction) _wrap_ScrolledWindow_GetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27846          { (char *)"ScrolledWindow_DoPrepareDC", (PyCFunction) _wrap_ScrolledWindow_DoPrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
27847          { (char *)"ScrolledWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrolledWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27848          { (char *)"ScrolledWindow_swigregister", ScrolledWindow_swigregister, METH_VARARGS, NULL},
27849          { (char *)"TopLevelWindow_Maximize", (PyCFunction) _wrap_TopLevelWindow_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
27850          { (char *)"TopLevelWindow_Restore", (PyCFunction) _wrap_TopLevelWindow_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
27851          { (char *)"TopLevelWindow_Iconize", (PyCFunction) _wrap_TopLevelWindow_Iconize, METH_VARARGS | METH_KEYWORDS, NULL},
27852          { (char *)"TopLevelWindow_IsMaximized", (PyCFunction) _wrap_TopLevelWindow_IsMaximized, METH_VARARGS | METH_KEYWORDS, NULL},
27853          { (char *)"TopLevelWindow_IsIconized", (PyCFunction) _wrap_TopLevelWindow_IsIconized, METH_VARARGS | METH_KEYWORDS, NULL},
27854          { (char *)"TopLevelWindow_GetIcon", (PyCFunction) _wrap_TopLevelWindow_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27855          { (char *)"TopLevelWindow_SetIcon", (PyCFunction) _wrap_TopLevelWindow_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27856          { (char *)"TopLevelWindow_SetIcons", (PyCFunction) _wrap_TopLevelWindow_SetIcons, METH_VARARGS | METH_KEYWORDS, NULL},
27857          { (char *)"TopLevelWindow_ShowFullScreen", (PyCFunction) _wrap_TopLevelWindow_ShowFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27858          { (char *)"TopLevelWindow_IsFullScreen", (PyCFunction) _wrap_TopLevelWindow_IsFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27859          { (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27860          { (char *)"TopLevelWindow_GetTitle", (PyCFunction) _wrap_TopLevelWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27861          { (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
27862          { (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
27863          { (char *)"TopLevelWindow_IsActive", (PyCFunction) _wrap_TopLevelWindow_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
27864          { (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27865          { (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacGetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27866          { (char *)"TopLevelWindow_swigregister", TopLevelWindow_swigregister, METH_VARARGS, NULL},
27867          { (char *)"new_Frame", (PyCFunction) _wrap_new_Frame, METH_VARARGS | METH_KEYWORDS, NULL},
27868          { (char *)"new_PreFrame", (PyCFunction) _wrap_new_PreFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27869          { (char *)"Frame_Create", (PyCFunction) _wrap_Frame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27870          { (char *)"Frame_GetClientAreaOrigin", (PyCFunction) _wrap_Frame_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
27871          { (char *)"Frame_SendSizeEvent", (PyCFunction) _wrap_Frame_SendSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27872          { (char *)"Frame_SetMenuBar", (PyCFunction) _wrap_Frame_SetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27873          { (char *)"Frame_GetMenuBar", (PyCFunction) _wrap_Frame_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27874          { (char *)"Frame_ProcessCommand", (PyCFunction) _wrap_Frame_ProcessCommand, METH_VARARGS | METH_KEYWORDS, NULL},
27875          { (char *)"Frame_CreateStatusBar", (PyCFunction) _wrap_Frame_CreateStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27876          { (char *)"Frame_GetStatusBar", (PyCFunction) _wrap_Frame_GetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27877          { (char *)"Frame_SetStatusBar", (PyCFunction) _wrap_Frame_SetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27878          { (char *)"Frame_SetStatusText", (PyCFunction) _wrap_Frame_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27879          { (char *)"Frame_SetStatusWidths", (PyCFunction) _wrap_Frame_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27880          { (char *)"Frame_PushStatusText", (PyCFunction) _wrap_Frame_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27881          { (char *)"Frame_PopStatusText", (PyCFunction) _wrap_Frame_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27882          { (char *)"Frame_SetStatusBarPane", (PyCFunction) _wrap_Frame_SetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27883          { (char *)"Frame_GetStatusBarPane", (PyCFunction) _wrap_Frame_GetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27884          { (char *)"Frame_CreateToolBar", (PyCFunction) _wrap_Frame_CreateToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27885          { (char *)"Frame_GetToolBar", (PyCFunction) _wrap_Frame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27886          { (char *)"Frame_SetToolBar", (PyCFunction) _wrap_Frame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27887          { (char *)"Frame_DoGiveHelp", (PyCFunction) _wrap_Frame_DoGiveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27888          { (char *)"Frame_DoMenuUpdates", (PyCFunction) _wrap_Frame_DoMenuUpdates, METH_VARARGS | METH_KEYWORDS, NULL},
27889          { (char *)"Frame_GetClassDefaultAttributes", (PyCFunction) _wrap_Frame_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27890          { (char *)"Frame_swigregister", Frame_swigregister, METH_VARARGS, NULL},
27891          { (char *)"new_Dialog", (PyCFunction) _wrap_new_Dialog, METH_VARARGS | METH_KEYWORDS, NULL},
27892          { (char *)"new_PreDialog", (PyCFunction) _wrap_new_PreDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27893          { (char *)"Dialog_Create", (PyCFunction) _wrap_Dialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27894          { (char *)"Dialog_SetReturnCode", (PyCFunction) _wrap_Dialog_SetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27895          { (char *)"Dialog_GetReturnCode", (PyCFunction) _wrap_Dialog_GetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27896          { (char *)"Dialog_CreateTextSizer", (PyCFunction) _wrap_Dialog_CreateTextSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27897          { (char *)"Dialog_CreateButtonSizer", (PyCFunction) _wrap_Dialog_CreateButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27898          { (char *)"Dialog_CreateStdDialogButtonSizer", (PyCFunction) _wrap_Dialog_CreateStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27899          { (char *)"Dialog_IsModal", (PyCFunction) _wrap_Dialog_IsModal, METH_VARARGS | METH_KEYWORDS, NULL},
27900          { (char *)"Dialog_ShowModal", (PyCFunction) _wrap_Dialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
27901          { (char *)"Dialog_EndModal", (PyCFunction) _wrap_Dialog_EndModal, METH_VARARGS | METH_KEYWORDS, NULL},
27902          { (char *)"Dialog_GetClassDefaultAttributes", (PyCFunction) _wrap_Dialog_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27903          { (char *)"Dialog_swigregister", Dialog_swigregister, METH_VARARGS, NULL},
27904          { (char *)"new_MiniFrame", (PyCFunction) _wrap_new_MiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27905          { (char *)"new_PreMiniFrame", (PyCFunction) _wrap_new_PreMiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27906          { (char *)"MiniFrame_Create", (PyCFunction) _wrap_MiniFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27907          { (char *)"MiniFrame_swigregister", MiniFrame_swigregister, METH_VARARGS, NULL},
27908          { (char *)"new_SplashScreenWindow", (PyCFunction) _wrap_new_SplashScreenWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27909          { (char *)"SplashScreenWindow_SetBitmap", (PyCFunction) _wrap_SplashScreenWindow_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27910          { (char *)"SplashScreenWindow_GetBitmap", (PyCFunction) _wrap_SplashScreenWindow_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27911          { (char *)"SplashScreenWindow_swigregister", SplashScreenWindow_swigregister, METH_VARARGS, NULL},
27912          { (char *)"new_SplashScreen", (PyCFunction) _wrap_new_SplashScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27913          { (char *)"SplashScreen_GetSplashStyle", (PyCFunction) _wrap_SplashScreen_GetSplashStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27914          { (char *)"SplashScreen_GetSplashWindow", (PyCFunction) _wrap_SplashScreen_GetSplashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27915          { (char *)"SplashScreen_GetTimeout", (PyCFunction) _wrap_SplashScreen_GetTimeout, METH_VARARGS | METH_KEYWORDS, NULL},
27916          { (char *)"SplashScreen_swigregister", SplashScreen_swigregister, METH_VARARGS, NULL},
27917          { (char *)"new_StatusBar", (PyCFunction) _wrap_new_StatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27918          { (char *)"new_PreStatusBar", (PyCFunction) _wrap_new_PreStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27919          { (char *)"StatusBar_Create", (PyCFunction) _wrap_StatusBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27920          { (char *)"StatusBar_SetFieldsCount", (PyCFunction) _wrap_StatusBar_SetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27921          { (char *)"StatusBar_GetFieldsCount", (PyCFunction) _wrap_StatusBar_GetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27922          { (char *)"StatusBar_SetStatusText", (PyCFunction) _wrap_StatusBar_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27923          { (char *)"StatusBar_GetStatusText", (PyCFunction) _wrap_StatusBar_GetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27924          { (char *)"StatusBar_PushStatusText", (PyCFunction) _wrap_StatusBar_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27925          { (char *)"StatusBar_PopStatusText", (PyCFunction) _wrap_StatusBar_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27926          { (char *)"StatusBar_SetStatusWidths", (PyCFunction) _wrap_StatusBar_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27927          { (char *)"StatusBar_SetStatusStyles", (PyCFunction) _wrap_StatusBar_SetStatusStyles, METH_VARARGS | METH_KEYWORDS, NULL},
27928          { (char *)"StatusBar_GetFieldRect", (PyCFunction) _wrap_StatusBar_GetFieldRect, METH_VARARGS | METH_KEYWORDS, NULL},
27929          { (char *)"StatusBar_SetMinHeight", (PyCFunction) _wrap_StatusBar_SetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
27930          { (char *)"StatusBar_GetBorderX", (PyCFunction) _wrap_StatusBar_GetBorderX, METH_VARARGS | METH_KEYWORDS, NULL},
27931          { (char *)"StatusBar_GetBorderY", (PyCFunction) _wrap_StatusBar_GetBorderY, METH_VARARGS | METH_KEYWORDS, NULL},
27932          { (char *)"StatusBar_GetClassDefaultAttributes", (PyCFunction) _wrap_StatusBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27933          { (char *)"StatusBar_swigregister", StatusBar_swigregister, METH_VARARGS, NULL},
27934          { (char *)"new_SplitterWindow", (PyCFunction) _wrap_new_SplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27935          { (char *)"new_PreSplitterWindow", (PyCFunction) _wrap_new_PreSplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27936          { (char *)"SplitterWindow_Create", (PyCFunction) _wrap_SplitterWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27937          { (char *)"SplitterWindow_GetWindow1", (PyCFunction) _wrap_SplitterWindow_GetWindow1, METH_VARARGS | METH_KEYWORDS, NULL},
27938          { (char *)"SplitterWindow_GetWindow2", (PyCFunction) _wrap_SplitterWindow_GetWindow2, METH_VARARGS | METH_KEYWORDS, NULL},
27939          { (char *)"SplitterWindow_SetSplitMode", (PyCFunction) _wrap_SplitterWindow_SetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27940          { (char *)"SplitterWindow_GetSplitMode", (PyCFunction) _wrap_SplitterWindow_GetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27941          { (char *)"SplitterWindow_Initialize", (PyCFunction) _wrap_SplitterWindow_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
27942          { (char *)"SplitterWindow_SplitVertically", (PyCFunction) _wrap_SplitterWindow_SplitVertically, METH_VARARGS | METH_KEYWORDS, NULL},
27943          { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL},
27944          { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL},
27945          { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27946          { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL},
27947          { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL},
27948          { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27949          { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27950          { (char *)"SplitterWindow_GetSashSize", (PyCFunction) _wrap_SplitterWindow_GetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27951          { (char *)"SplitterWindow_GetBorderSize", (PyCFunction) _wrap_SplitterWindow_GetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27952          { (char *)"SplitterWindow_SetSashPosition", (PyCFunction) _wrap_SplitterWindow_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27953          { (char *)"SplitterWindow_GetSashPosition", (PyCFunction) _wrap_SplitterWindow_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27954          { (char *)"SplitterWindow_SetSashGravity", (PyCFunction) _wrap_SplitterWindow_SetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27955          { (char *)"SplitterWindow_GetSashGravity", (PyCFunction) _wrap_SplitterWindow_GetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27956          { (char *)"SplitterWindow_SetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_SetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27957          { (char *)"SplitterWindow_GetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_GetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27958          { (char *)"SplitterWindow_SashHitTest", (PyCFunction) _wrap_SplitterWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27959          { (char *)"SplitterWindow_SizeWindows", (PyCFunction) _wrap_SplitterWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27960          { (char *)"SplitterWindow_SetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_SetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27961          { (char *)"SplitterWindow_GetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_GetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27962          { (char *)"SplitterWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_SplitterWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27963          { (char *)"SplitterWindow_swigregister", SplitterWindow_swigregister, METH_VARARGS, NULL},
27964          { (char *)"new_SplitterEvent", (PyCFunction) _wrap_new_SplitterEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27965          { (char *)"SplitterEvent_SetSashPosition", (PyCFunction) _wrap_SplitterEvent_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27966          { (char *)"SplitterEvent_GetSashPosition", (PyCFunction) _wrap_SplitterEvent_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27967          { (char *)"SplitterEvent_GetWindowBeingRemoved", (PyCFunction) _wrap_SplitterEvent_GetWindowBeingRemoved, METH_VARARGS | METH_KEYWORDS, NULL},
27968          { (char *)"SplitterEvent_GetX", (PyCFunction) _wrap_SplitterEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
27969          { (char *)"SplitterEvent_GetY", (PyCFunction) _wrap_SplitterEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
27970          { (char *)"SplitterEvent_swigregister", SplitterEvent_swigregister, METH_VARARGS, NULL},
27971          { (char *)"new_SashWindow", (PyCFunction) _wrap_new_SashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27972          { (char *)"new_PreSashWindow", (PyCFunction) _wrap_new_PreSashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27973          { (char *)"SashWindow_Create", (PyCFunction) _wrap_SashWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27974          { (char *)"SashWindow_SetSashVisible", (PyCFunction) _wrap_SashWindow_SetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27975          { (char *)"SashWindow_GetSashVisible", (PyCFunction) _wrap_SashWindow_GetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27976          { (char *)"SashWindow_SetSashBorder", (PyCFunction) _wrap_SashWindow_SetSashBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27977          { (char *)"SashWindow_HasBorder", (PyCFunction) _wrap_SashWindow_HasBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27978          { (char *)"SashWindow_GetEdgeMargin", (PyCFunction) _wrap_SashWindow_GetEdgeMargin, METH_VARARGS | METH_KEYWORDS, NULL},
27979          { (char *)"SashWindow_SetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_SetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27980          { (char *)"SashWindow_GetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_GetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27981          { (char *)"SashWindow_SetExtraBorderSize", (PyCFunction) _wrap_SashWindow_SetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27982          { (char *)"SashWindow_GetExtraBorderSize", (PyCFunction) _wrap_SashWindow_GetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27983          { (char *)"SashWindow_SetMinimumSizeX", (PyCFunction) _wrap_SashWindow_SetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27984          { (char *)"SashWindow_SetMinimumSizeY", (PyCFunction) _wrap_SashWindow_SetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27985          { (char *)"SashWindow_GetMinimumSizeX", (PyCFunction) _wrap_SashWindow_GetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27986          { (char *)"SashWindow_GetMinimumSizeY", (PyCFunction) _wrap_SashWindow_GetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27987          { (char *)"SashWindow_SetMaximumSizeX", (PyCFunction) _wrap_SashWindow_SetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27988          { (char *)"SashWindow_SetMaximumSizeY", (PyCFunction) _wrap_SashWindow_SetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27989          { (char *)"SashWindow_GetMaximumSizeX", (PyCFunction) _wrap_SashWindow_GetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27990          { (char *)"SashWindow_GetMaximumSizeY", (PyCFunction) _wrap_SashWindow_GetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27991          { (char *)"SashWindow_SashHitTest", (PyCFunction) _wrap_SashWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27992          { (char *)"SashWindow_SizeWindows", (PyCFunction) _wrap_SashWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27993          { (char *)"SashWindow_swigregister", SashWindow_swigregister, METH_VARARGS, NULL},
27994          { (char *)"new_SashEvent", (PyCFunction) _wrap_new_SashEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27995          { (char *)"SashEvent_SetEdge", (PyCFunction) _wrap_SashEvent_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27996          { (char *)"SashEvent_GetEdge", (PyCFunction) _wrap_SashEvent_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27997          { (char *)"SashEvent_SetDragRect", (PyCFunction) _wrap_SashEvent_SetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27998          { (char *)"SashEvent_GetDragRect", (PyCFunction) _wrap_SashEvent_GetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27999          { (char *)"SashEvent_SetDragStatus", (PyCFunction) _wrap_SashEvent_SetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
28000          { (char *)"SashEvent_GetDragStatus", (PyCFunction) _wrap_SashEvent_GetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
28001          { (char *)"SashEvent_swigregister", SashEvent_swigregister, METH_VARARGS, NULL},
28002          { (char *)"new_QueryLayoutInfoEvent", (PyCFunction) _wrap_new_QueryLayoutInfoEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28003          { (char *)"QueryLayoutInfoEvent_SetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
28004          { (char *)"QueryLayoutInfoEvent_GetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
28005          { (char *)"QueryLayoutInfoEvent_SetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28006          { (char *)"QueryLayoutInfoEvent_GetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28007          { (char *)"QueryLayoutInfoEvent_SetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28008          { (char *)"QueryLayoutInfoEvent_GetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28009          { (char *)"QueryLayoutInfoEvent_SetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28010          { (char *)"QueryLayoutInfoEvent_GetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28011          { (char *)"QueryLayoutInfoEvent_SetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28012          { (char *)"QueryLayoutInfoEvent_GetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28013          { (char *)"QueryLayoutInfoEvent_swigregister", QueryLayoutInfoEvent_swigregister, METH_VARARGS, NULL},
28014          { (char *)"new_CalculateLayoutEvent", (PyCFunction) _wrap_new_CalculateLayoutEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28015          { (char *)"CalculateLayoutEvent_SetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28016          { (char *)"CalculateLayoutEvent_GetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28017          { (char *)"CalculateLayoutEvent_SetRect", (PyCFunction) _wrap_CalculateLayoutEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
28018          { (char *)"CalculateLayoutEvent_GetRect", (PyCFunction) _wrap_CalculateLayoutEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
28019          { (char *)"CalculateLayoutEvent_swigregister", CalculateLayoutEvent_swigregister, METH_VARARGS, NULL},
28020          { (char *)"new_SashLayoutWindow", (PyCFunction) _wrap_new_SashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28021          { (char *)"new_PreSashLayoutWindow", (PyCFunction) _wrap_new_PreSashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28022          { (char *)"SashLayoutWindow_Create", (PyCFunction) _wrap_SashLayoutWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28023          { (char *)"SashLayoutWindow_GetAlignment", (PyCFunction) _wrap_SashLayoutWindow_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28024          { (char *)"SashLayoutWindow_GetOrientation", (PyCFunction) _wrap_SashLayoutWindow_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28025          { (char *)"SashLayoutWindow_SetAlignment", (PyCFunction) _wrap_SashLayoutWindow_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28026          { (char *)"SashLayoutWindow_SetDefaultSize", (PyCFunction) _wrap_SashLayoutWindow_SetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
28027          { (char *)"SashLayoutWindow_SetOrientation", (PyCFunction) _wrap_SashLayoutWindow_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28028          { (char *)"SashLayoutWindow_swigregister", SashLayoutWindow_swigregister, METH_VARARGS, NULL},
28029          { (char *)"new_LayoutAlgorithm", (PyCFunction) _wrap_new_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
28030          { (char *)"delete_LayoutAlgorithm", (PyCFunction) _wrap_delete_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
28031          { (char *)"LayoutAlgorithm_LayoutMDIFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutMDIFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28032          { (char *)"LayoutAlgorithm_LayoutFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28033          { (char *)"LayoutAlgorithm_LayoutWindow", (PyCFunction) _wrap_LayoutAlgorithm_LayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28034          { (char *)"LayoutAlgorithm_swigregister", LayoutAlgorithm_swigregister, METH_VARARGS, NULL},
28035          { (char *)"new_PopupWindow", (PyCFunction) _wrap_new_PopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28036          { (char *)"new_PrePopupWindow", (PyCFunction) _wrap_new_PrePopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28037          { (char *)"PopupWindow_Create", (PyCFunction) _wrap_PopupWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28038          { (char *)"PopupWindow_Position", (PyCFunction) _wrap_PopupWindow_Position, METH_VARARGS | METH_KEYWORDS, NULL},
28039          { (char *)"PopupWindow_swigregister", PopupWindow_swigregister, METH_VARARGS, NULL},
28040          { (char *)"new_PopupTransientWindow", (PyCFunction) _wrap_new_PopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28041          { (char *)"new_PrePopupTransientWindow", (PyCFunction) _wrap_new_PrePopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28042          { (char *)"PopupTransientWindow__setCallbackInfo", (PyCFunction) _wrap_PopupTransientWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28043          { (char *)"PopupTransientWindow_Popup", (PyCFunction) _wrap_PopupTransientWindow_Popup, METH_VARARGS | METH_KEYWORDS, NULL},
28044          { (char *)"PopupTransientWindow_Dismiss", (PyCFunction) _wrap_PopupTransientWindow_Dismiss, METH_VARARGS | METH_KEYWORDS, NULL},
28045          { (char *)"PopupTransientWindow_swigregister", PopupTransientWindow_swigregister, METH_VARARGS, NULL},
28046          { (char *)"new_TipWindow", (PyCFunction) _wrap_new_TipWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28047          { (char *)"TipWindow_SetBoundingRect", (PyCFunction) _wrap_TipWindow_SetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
28048          { (char *)"TipWindow_Close", (PyCFunction) _wrap_TipWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
28049          { (char *)"TipWindow_swigregister", TipWindow_swigregister, METH_VARARGS, NULL},
28050          { (char *)"new_VScrolledWindow", (PyCFunction) _wrap_new_VScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28051          { (char *)"new_PreVScrolledWindow", (PyCFunction) _wrap_new_PreVScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28052          { (char *)"VScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_VScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28053          { (char *)"VScrolledWindow_Create", (PyCFunction) _wrap_VScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28054          { (char *)"VScrolledWindow_SetLineCount", (PyCFunction) _wrap_VScrolledWindow_SetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
28055          { (char *)"VScrolledWindow_ScrollToLine", (PyCFunction) _wrap_VScrolledWindow_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},
28056          { (char *)"VScrolledWindow_ScrollLines", (PyCFunction) _wrap_VScrolledWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
28057          { (char *)"VScrolledWindow_ScrollPages", (PyCFunction) _wrap_VScrolledWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
28058          { (char *)"VScrolledWindow_RefreshLine", (PyCFunction) _wrap_VScrolledWindow_RefreshLine, METH_VARARGS | METH_KEYWORDS, NULL},
28059          { (char *)"VScrolledWindow_RefreshLines", (PyCFunction) _wrap_VScrolledWindow_RefreshLines, METH_VARARGS | METH_KEYWORDS, NULL},
28060          { (char *)"VScrolledWindow_HitTestXY", (PyCFunction) _wrap_VScrolledWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
28061          { (char *)"VScrolledWindow_HitTest", (PyCFunction) _wrap_VScrolledWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
28062          { (char *)"VScrolledWindow_RefreshAll", (PyCFunction) _wrap_VScrolledWindow_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
28063          { (char *)"VScrolledWindow_GetLineCount", (PyCFunction) _wrap_VScrolledWindow_GetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
28064          { (char *)"VScrolledWindow_GetFirstVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetFirstVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
28065          { (char *)"VScrolledWindow_GetLastVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetLastVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
28066          { (char *)"VScrolledWindow_IsVisible", (PyCFunction) _wrap_VScrolledWindow_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
28067          { (char *)"VScrolledWindow_swigregister", VScrolledWindow_swigregister, METH_VARARGS, NULL},
28068          { (char *)"new_VListBox", (PyCFunction) _wrap_new_VListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28069          { (char *)"new_PreVListBox", (PyCFunction) _wrap_new_PreVListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28070          { (char *)"VListBox__setCallbackInfo", (PyCFunction) _wrap_VListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28071          { (char *)"VListBox_Create", (PyCFunction) _wrap_VListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28072          { (char *)"VListBox_GetItemCount", (PyCFunction) _wrap_VListBox_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28073          { (char *)"VListBox_HasMultipleSelection", (PyCFunction) _wrap_VListBox_HasMultipleSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28074          { (char *)"VListBox_GetSelection", (PyCFunction) _wrap_VListBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28075          { (char *)"VListBox_IsCurrent", (PyCFunction) _wrap_VListBox_IsCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
28076          { (char *)"VListBox_IsSelected", (PyCFunction) _wrap_VListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28077          { (char *)"VListBox_GetSelectedCount", (PyCFunction) _wrap_VListBox_GetSelectedCount, METH_VARARGS | METH_KEYWORDS, NULL},
28078          { (char *)"VListBox_GetFirstSelected", (PyCFunction) _wrap_VListBox_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28079          { (char *)"VListBox_GetNextSelected", (PyCFunction) _wrap_VListBox_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28080          { (char *)"VListBox_GetMargins", (PyCFunction) _wrap_VListBox_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28081          { (char *)"VListBox_GetSelectionBackground", (PyCFunction) _wrap_VListBox_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28082          { (char *)"VListBox_SetItemCount", (PyCFunction) _wrap_VListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28083          { (char *)"VListBox_Clear", (PyCFunction) _wrap_VListBox_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
28084          { (char *)"VListBox_SetSelection", (PyCFunction) _wrap_VListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28085          { (char *)"VListBox_Select", (PyCFunction) _wrap_VListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
28086          { (char *)"VListBox_SelectRange", (PyCFunction) _wrap_VListBox_SelectRange, METH_VARARGS | METH_KEYWORDS, NULL},
28087          { (char *)"VListBox_Toggle", (PyCFunction) _wrap_VListBox_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
28088          { (char *)"VListBox_SelectAll", (PyCFunction) _wrap_VListBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
28089          { (char *)"VListBox_DeselectAll", (PyCFunction) _wrap_VListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
28090          { (char *)"VListBox_SetMargins", (PyCFunction) _wrap_VListBox_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28091          { (char *)"VListBox_SetMarginsXY", (PyCFunction) _wrap_VListBox_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
28092          { (char *)"VListBox_SetSelectionBackground", (PyCFunction) _wrap_VListBox_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28093          { (char *)"VListBox_swigregister", VListBox_swigregister, METH_VARARGS, NULL},
28094          { (char *)"new_HtmlListBox", (PyCFunction) _wrap_new_HtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28095          { (char *)"new_PreHtmlListBox", (PyCFunction) _wrap_new_PreHtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28096          { (char *)"HtmlListBox__setCallbackInfo", (PyCFunction) _wrap_HtmlListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28097          { (char *)"HtmlListBox_Create", (PyCFunction) _wrap_HtmlListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28098          { (char *)"HtmlListBox_RefreshAll", (PyCFunction) _wrap_HtmlListBox_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
28099          { (char *)"HtmlListBox_SetItemCount", (PyCFunction) _wrap_HtmlListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28100          { (char *)"HtmlListBox_GetFileSystem", (PyCFunction) _wrap_HtmlListBox_GetFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
28101          { (char *)"HtmlListBox_swigregister", HtmlListBox_swigregister, METH_VARARGS, NULL},
28102          { (char *)"new_TaskBarIcon", (PyCFunction) _wrap_new_TaskBarIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28103          { (char *)"TaskBarIcon__setCallbackInfo", (PyCFunction) _wrap_TaskBarIcon__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28104          { (char *)"TaskBarIcon_Destroy", (PyCFunction) _wrap_TaskBarIcon_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
28105          { (char *)"TaskBarIcon_IsOk", (PyCFunction) _wrap_TaskBarIcon_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
28106          { (char *)"TaskBarIcon_IsIconInstalled", (PyCFunction) _wrap_TaskBarIcon_IsIconInstalled, METH_VARARGS | METH_KEYWORDS, NULL},
28107          { (char *)"TaskBarIcon_SetIcon", (PyCFunction) _wrap_TaskBarIcon_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28108          { (char *)"TaskBarIcon_RemoveIcon", (PyCFunction) _wrap_TaskBarIcon_RemoveIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28109          { (char *)"TaskBarIcon_PopupMenu", (PyCFunction) _wrap_TaskBarIcon_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28110          { (char *)"TaskBarIcon_swigregister", TaskBarIcon_swigregister, METH_VARARGS, NULL},
28111          { (char *)"new_TaskBarIconEvent", (PyCFunction) _wrap_new_TaskBarIconEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28112          { (char *)"TaskBarIconEvent_swigregister", TaskBarIconEvent_swigregister, METH_VARARGS, NULL},
28113          { (char *)"new_ColourData", (PyCFunction) _wrap_new_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28114          { (char *)"delete_ColourData", (PyCFunction) _wrap_delete_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28115          { (char *)"ColourData_GetChooseFull", (PyCFunction) _wrap_ColourData_GetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
28116          { (char *)"ColourData_GetColour", (PyCFunction) _wrap_ColourData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28117          { (char *)"ColourData_GetCustomColour", (PyCFunction) _wrap_ColourData_GetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
28118          { (char *)"ColourData_SetChooseFull", (PyCFunction) _wrap_ColourData_SetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
28119          { (char *)"ColourData_SetColour", (PyCFunction) _wrap_ColourData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28120          { (char *)"ColourData_SetCustomColour", (PyCFunction) _wrap_ColourData_SetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
28121          { (char *)"ColourData_swigregister", ColourData_swigregister, METH_VARARGS, NULL},
28122          { (char *)"new_ColourDialog", (PyCFunction) _wrap_new_ColourDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28123          { (char *)"ColourDialog_GetColourData", (PyCFunction) _wrap_ColourDialog_GetColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28124          { (char *)"ColourDialog_swigregister", ColourDialog_swigregister, METH_VARARGS, NULL},
28125          { (char *)"new_DirDialog", (PyCFunction) _wrap_new_DirDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28126          { (char *)"DirDialog_GetPath", (PyCFunction) _wrap_DirDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28127          { (char *)"DirDialog_GetMessage", (PyCFunction) _wrap_DirDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28128          { (char *)"DirDialog_GetStyle", (PyCFunction) _wrap_DirDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28129          { (char *)"DirDialog_SetMessage", (PyCFunction) _wrap_DirDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28130          { (char *)"DirDialog_SetPath", (PyCFunction) _wrap_DirDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28131          { (char *)"DirDialog_swigregister", DirDialog_swigregister, METH_VARARGS, NULL},
28132          { (char *)"new_FileDialog", (PyCFunction) _wrap_new_FileDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28133          { (char *)"FileDialog_SetMessage", (PyCFunction) _wrap_FileDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28134          { (char *)"FileDialog_SetPath", (PyCFunction) _wrap_FileDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28135          { (char *)"FileDialog_SetDirectory", (PyCFunction) _wrap_FileDialog_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
28136          { (char *)"FileDialog_SetFilename", (PyCFunction) _wrap_FileDialog_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28137          { (char *)"FileDialog_SetWildcard", (PyCFunction) _wrap_FileDialog_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
28138          { (char *)"FileDialog_SetStyle", (PyCFunction) _wrap_FileDialog_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28139          { (char *)"FileDialog_SetFilterIndex", (PyCFunction) _wrap_FileDialog_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
28140          { (char *)"FileDialog_GetMessage", (PyCFunction) _wrap_FileDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28141          { (char *)"FileDialog_GetPath", (PyCFunction) _wrap_FileDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28142          { (char *)"FileDialog_GetDirectory", (PyCFunction) _wrap_FileDialog_GetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
28143          { (char *)"FileDialog_GetFilename", (PyCFunction) _wrap_FileDialog_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28144          { (char *)"FileDialog_GetWildcard", (PyCFunction) _wrap_FileDialog_GetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
28145          { (char *)"FileDialog_GetStyle", (PyCFunction) _wrap_FileDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28146          { (char *)"FileDialog_GetFilterIndex", (PyCFunction) _wrap_FileDialog_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
28147          { (char *)"FileDialog_GetFilenames", (PyCFunction) _wrap_FileDialog_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
28148          { (char *)"FileDialog_GetPaths", (PyCFunction) _wrap_FileDialog_GetPaths, METH_VARARGS | METH_KEYWORDS, NULL},
28149          { (char *)"FileDialog_swigregister", FileDialog_swigregister, METH_VARARGS, NULL},
28150          { (char *)"new_MultiChoiceDialog", (PyCFunction) _wrap_new_MultiChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28151          { (char *)"MultiChoiceDialog_SetSelections", (PyCFunction) _wrap_MultiChoiceDialog_SetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28152          { (char *)"MultiChoiceDialog_GetSelections", (PyCFunction) _wrap_MultiChoiceDialog_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28153          { (char *)"MultiChoiceDialog_swigregister", MultiChoiceDialog_swigregister, METH_VARARGS, NULL},
28154          { (char *)"new_SingleChoiceDialog", (PyCFunction) _wrap_new_SingleChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28155          { (char *)"SingleChoiceDialog_GetSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28156          { (char *)"SingleChoiceDialog_GetStringSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28157          { (char *)"SingleChoiceDialog_SetSelection", (PyCFunction) _wrap_SingleChoiceDialog_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28158          { (char *)"SingleChoiceDialog_swigregister", SingleChoiceDialog_swigregister, METH_VARARGS, NULL},
28159          { (char *)"new_TextEntryDialog", (PyCFunction) _wrap_new_TextEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28160          { (char *)"TextEntryDialog_GetValue", (PyCFunction) _wrap_TextEntryDialog_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28161          { (char *)"TextEntryDialog_SetValue", (PyCFunction) _wrap_TextEntryDialog_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28162          { (char *)"TextEntryDialog_swigregister", TextEntryDialog_swigregister, METH_VARARGS, NULL},
28163          { (char *)"new_PasswordEntryDialog", (PyCFunction) _wrap_new_PasswordEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28164          { (char *)"PasswordEntryDialog_swigregister", PasswordEntryDialog_swigregister, METH_VARARGS, NULL},
28165          { (char *)"new_FontData", (PyCFunction) _wrap_new_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28166          { (char *)"delete_FontData", (PyCFunction) _wrap_delete_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28167          { (char *)"FontData_EnableEffects", (PyCFunction) _wrap_FontData_EnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28168          { (char *)"FontData_GetAllowSymbols", (PyCFunction) _wrap_FontData_GetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28169          { (char *)"FontData_GetColour", (PyCFunction) _wrap_FontData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28170          { (char *)"FontData_GetChosenFont", (PyCFunction) _wrap_FontData_GetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28171          { (char *)"FontData_GetEnableEffects", (PyCFunction) _wrap_FontData_GetEnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28172          { (char *)"FontData_GetInitialFont", (PyCFunction) _wrap_FontData_GetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28173          { (char *)"FontData_GetShowHelp", (PyCFunction) _wrap_FontData_GetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28174          { (char *)"FontData_SetAllowSymbols", (PyCFunction) _wrap_FontData_SetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28175          { (char *)"FontData_SetChosenFont", (PyCFunction) _wrap_FontData_SetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28176          { (char *)"FontData_SetColour", (PyCFunction) _wrap_FontData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28177          { (char *)"FontData_SetInitialFont", (PyCFunction) _wrap_FontData_SetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28178          { (char *)"FontData_SetRange", (PyCFunction) _wrap_FontData_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
28179          { (char *)"FontData_SetShowHelp", (PyCFunction) _wrap_FontData_SetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28180          { (char *)"FontData_swigregister", FontData_swigregister, METH_VARARGS, NULL},
28181          { (char *)"new_FontDialog", (PyCFunction) _wrap_new_FontDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28182          { (char *)"FontDialog_GetFontData", (PyCFunction) _wrap_FontDialog_GetFontData, METH_VARARGS | METH_KEYWORDS, NULL},
28183          { (char *)"FontDialog_swigregister", FontDialog_swigregister, METH_VARARGS, NULL},
28184          { (char *)"new_MessageDialog", (PyCFunction) _wrap_new_MessageDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28185          { (char *)"MessageDialog_swigregister", MessageDialog_swigregister, METH_VARARGS, NULL},
28186          { (char *)"new_ProgressDialog", (PyCFunction) _wrap_new_ProgressDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28187          { (char *)"ProgressDialog_Update", (PyCFunction) _wrap_ProgressDialog_Update, METH_VARARGS | METH_KEYWORDS, NULL},
28188          { (char *)"ProgressDialog_Resume", (PyCFunction) _wrap_ProgressDialog_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
28189          { (char *)"ProgressDialog_swigregister", ProgressDialog_swigregister, METH_VARARGS, NULL},
28190          { (char *)"new_FindDialogEvent", (PyCFunction) _wrap_new_FindDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28191          { (char *)"FindDialogEvent_GetFlags", (PyCFunction) _wrap_FindDialogEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28192          { (char *)"FindDialogEvent_GetFindString", (PyCFunction) _wrap_FindDialogEvent_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28193          { (char *)"FindDialogEvent_GetReplaceString", (PyCFunction) _wrap_FindDialogEvent_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28194          { (char *)"FindDialogEvent_GetDialog", (PyCFunction) _wrap_FindDialogEvent_GetDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28195          { (char *)"FindDialogEvent_SetFlags", (PyCFunction) _wrap_FindDialogEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28196          { (char *)"FindDialogEvent_SetFindString", (PyCFunction) _wrap_FindDialogEvent_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28197          { (char *)"FindDialogEvent_SetReplaceString", (PyCFunction) _wrap_FindDialogEvent_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28198          { (char *)"FindDialogEvent_swigregister", FindDialogEvent_swigregister, METH_VARARGS, NULL},
28199          { (char *)"new_FindReplaceData", (PyCFunction) _wrap_new_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28200          { (char *)"delete_FindReplaceData", (PyCFunction) _wrap_delete_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28201          { (char *)"FindReplaceData_GetFindString", (PyCFunction) _wrap_FindReplaceData_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28202          { (char *)"FindReplaceData_GetReplaceString", (PyCFunction) _wrap_FindReplaceData_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28203          { (char *)"FindReplaceData_GetFlags", (PyCFunction) _wrap_FindReplaceData_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28204          { (char *)"FindReplaceData_SetFlags", (PyCFunction) _wrap_FindReplaceData_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28205          { (char *)"FindReplaceData_SetFindString", (PyCFunction) _wrap_FindReplaceData_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28206          { (char *)"FindReplaceData_SetReplaceString", (PyCFunction) _wrap_FindReplaceData_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28207          { (char *)"FindReplaceData_swigregister", FindReplaceData_swigregister, METH_VARARGS, NULL},
28208          { (char *)"new_FindReplaceDialog", (PyCFunction) _wrap_new_FindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28209          { (char *)"new_PreFindReplaceDialog", (PyCFunction) _wrap_new_PreFindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28210          { (char *)"FindReplaceDialog_Create", (PyCFunction) _wrap_FindReplaceDialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28211          { (char *)"FindReplaceDialog_GetData", (PyCFunction) _wrap_FindReplaceDialog_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
28212          { (char *)"FindReplaceDialog_SetData", (PyCFunction) _wrap_FindReplaceDialog_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
28213          { (char *)"FindReplaceDialog_swigregister", FindReplaceDialog_swigregister, METH_VARARGS, NULL},
28214          { (char *)"new_MDIParentFrame", (PyCFunction) _wrap_new_MDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28215          { (char *)"new_PreMDIParentFrame", (PyCFunction) _wrap_new_PreMDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28216          { (char *)"MDIParentFrame_Create", (PyCFunction) _wrap_MDIParentFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28217          { (char *)"MDIParentFrame_ActivateNext", (PyCFunction) _wrap_MDIParentFrame_ActivateNext, METH_VARARGS | METH_KEYWORDS, NULL},
28218          { (char *)"MDIParentFrame_ActivatePrevious", (PyCFunction) _wrap_MDIParentFrame_ActivatePrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28219          { (char *)"MDIParentFrame_ArrangeIcons", (PyCFunction) _wrap_MDIParentFrame_ArrangeIcons, METH_VARARGS | METH_KEYWORDS, NULL},
28220          { (char *)"MDIParentFrame_Cascade", (PyCFunction) _wrap_MDIParentFrame_Cascade, METH_VARARGS | METH_KEYWORDS, NULL},
28221          { (char *)"MDIParentFrame_GetActiveChild", (PyCFunction) _wrap_MDIParentFrame_GetActiveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28222          { (char *)"MDIParentFrame_GetClientWindow", (PyCFunction) _wrap_MDIParentFrame_GetClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28223          { (char *)"MDIParentFrame_GetToolBar", (PyCFunction) _wrap_MDIParentFrame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28224          { (char *)"MDIParentFrame_GetWindowMenu", (PyCFunction) _wrap_MDIParentFrame_GetWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28225          { (char *)"MDIParentFrame_SetWindowMenu", (PyCFunction) _wrap_MDIParentFrame_SetWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28226          { (char *)"MDIParentFrame_SetToolBar", (PyCFunction) _wrap_MDIParentFrame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28227          { (char *)"MDIParentFrame_Tile", (PyCFunction) _wrap_MDIParentFrame_Tile, METH_VARARGS | METH_KEYWORDS, NULL},
28228          { (char *)"MDIParentFrame_swigregister", MDIParentFrame_swigregister, METH_VARARGS, NULL},
28229          { (char *)"new_MDIChildFrame", (PyCFunction) _wrap_new_MDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28230          { (char *)"new_PreMDIChildFrame", (PyCFunction) _wrap_new_PreMDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28231          { (char *)"MDIChildFrame_Create", (PyCFunction) _wrap_MDIChildFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28232          { (char *)"MDIChildFrame_Activate", (PyCFunction) _wrap_MDIChildFrame_Activate, METH_VARARGS | METH_KEYWORDS, NULL},
28233          { (char *)"MDIChildFrame_Maximize", (PyCFunction) _wrap_MDIChildFrame_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
28234          { (char *)"MDIChildFrame_Restore", (PyCFunction) _wrap_MDIChildFrame_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
28235          { (char *)"MDIChildFrame_swigregister", MDIChildFrame_swigregister, METH_VARARGS, NULL},
28236          { (char *)"new_MDIClientWindow", (PyCFunction) _wrap_new_MDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28237          { (char *)"new_PreMDIClientWindow", (PyCFunction) _wrap_new_PreMDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28238          { (char *)"MDIClientWindow_Create", (PyCFunction) _wrap_MDIClientWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28239          { (char *)"MDIClientWindow_swigregister", MDIClientWindow_swigregister, METH_VARARGS, NULL},
28240          { (char *)"new_PyWindow", (PyCFunction) _wrap_new_PyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28241          { (char *)"new_PrePyWindow", (PyCFunction) _wrap_new_PrePyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28242          { (char *)"PyWindow__setCallbackInfo", (PyCFunction) _wrap_PyWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28243          { (char *)"PyWindow_SetBestSize", (PyCFunction) _wrap_PyWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28244          { (char *)"PyWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28245          { (char *)"PyWindow_base_DoSetSize", (PyCFunction) _wrap_PyWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28246          { (char *)"PyWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28247          { (char *)"PyWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28248          { (char *)"PyWindow_base_DoGetSize", (PyCFunction) _wrap_PyWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28249          { (char *)"PyWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28250          { (char *)"PyWindow_base_DoGetPosition", (PyCFunction) _wrap_PyWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28251          { (char *)"PyWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28252          { (char *)"PyWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28253          { (char *)"PyWindow_base_InitDialog", (PyCFunction) _wrap_PyWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28254          { (char *)"PyWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28255          { (char *)"PyWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28256          { (char *)"PyWindow_base_Validate", (PyCFunction) _wrap_PyWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28257          { (char *)"PyWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28258          { (char *)"PyWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28259          { (char *)"PyWindow_base_GetMaxSize", (PyCFunction) _wrap_PyWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28260          { (char *)"PyWindow_base_AddChild", (PyCFunction) _wrap_PyWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28261          { (char *)"PyWindow_base_RemoveChild", (PyCFunction) _wrap_PyWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28262          { (char *)"PyWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28263          { (char *)"PyWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28264          { (char *)"PyWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28265          { (char *)"PyWindow_swigregister", PyWindow_swigregister, METH_VARARGS, NULL},
28266          { (char *)"new_PyPanel", (PyCFunction) _wrap_new_PyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28267          { (char *)"new_PrePyPanel", (PyCFunction) _wrap_new_PrePyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28268          { (char *)"PyPanel__setCallbackInfo", (PyCFunction) _wrap_PyPanel__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28269          { (char *)"PyPanel_SetBestSize", (PyCFunction) _wrap_PyPanel_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28270          { (char *)"PyPanel_base_DoMoveWindow", (PyCFunction) _wrap_PyPanel_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28271          { (char *)"PyPanel_base_DoSetSize", (PyCFunction) _wrap_PyPanel_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28272          { (char *)"PyPanel_base_DoSetClientSize", (PyCFunction) _wrap_PyPanel_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28273          { (char *)"PyPanel_base_DoSetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28274          { (char *)"PyPanel_base_DoGetSize", (PyCFunction) _wrap_PyPanel_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28275          { (char *)"PyPanel_base_DoGetClientSize", (PyCFunction) _wrap_PyPanel_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28276          { (char *)"PyPanel_base_DoGetPosition", (PyCFunction) _wrap_PyPanel_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28277          { (char *)"PyPanel_base_DoGetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28278          { (char *)"PyPanel_base_DoGetBestSize", (PyCFunction) _wrap_PyPanel_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28279          { (char *)"PyPanel_base_InitDialog", (PyCFunction) _wrap_PyPanel_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28280          { (char *)"PyPanel_base_TransferDataToWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28281          { (char *)"PyPanel_base_TransferDataFromWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28282          { (char *)"PyPanel_base_Validate", (PyCFunction) _wrap_PyPanel_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28283          { (char *)"PyPanel_base_AcceptsFocus", (PyCFunction) _wrap_PyPanel_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28284          { (char *)"PyPanel_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyPanel_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28285          { (char *)"PyPanel_base_GetMaxSize", (PyCFunction) _wrap_PyPanel_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28286          { (char *)"PyPanel_base_AddChild", (PyCFunction) _wrap_PyPanel_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28287          { (char *)"PyPanel_base_RemoveChild", (PyCFunction) _wrap_PyPanel_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28288          { (char *)"PyPanel_base_ShouldInheritColours", (PyCFunction) _wrap_PyPanel_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28289          { (char *)"PyPanel_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyPanel_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28290          { (char *)"PyPanel_base_GetDefaultAttributes", (PyCFunction) _wrap_PyPanel_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28291          { (char *)"PyPanel_swigregister", PyPanel_swigregister, METH_VARARGS, NULL},
28292          { (char *)"new_PyScrolledWindow", (PyCFunction) _wrap_new_PyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28293          { (char *)"new_PrePyScrolledWindow", (PyCFunction) _wrap_new_PrePyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28294          { (char *)"PyScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_PyScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28295          { (char *)"PyScrolledWindow_SetBestSize", (PyCFunction) _wrap_PyScrolledWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28296          { (char *)"PyScrolledWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyScrolledWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28297          { (char *)"PyScrolledWindow_base_DoSetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28298          { (char *)"PyScrolledWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28299          { (char *)"PyScrolledWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28300          { (char *)"PyScrolledWindow_base_DoGetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28301          { (char *)"PyScrolledWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28302          { (char *)"PyScrolledWindow_base_DoGetPosition", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28303          { (char *)"PyScrolledWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28304          { (char *)"PyScrolledWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28305          { (char *)"PyScrolledWindow_base_InitDialog", (PyCFunction) _wrap_PyScrolledWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28306          { (char *)"PyScrolledWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28307          { (char *)"PyScrolledWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28308          { (char *)"PyScrolledWindow_base_Validate", (PyCFunction) _wrap_PyScrolledWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28309          { (char *)"PyScrolledWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28310          { (char *)"PyScrolledWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28311          { (char *)"PyScrolledWindow_base_GetMaxSize", (PyCFunction) _wrap_PyScrolledWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28312          { (char *)"PyScrolledWindow_base_AddChild", (PyCFunction) _wrap_PyScrolledWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28313          { (char *)"PyScrolledWindow_base_RemoveChild", (PyCFunction) _wrap_PyScrolledWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28314          { (char *)"PyScrolledWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyScrolledWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28315          { (char *)"PyScrolledWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyScrolledWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28316          { (char *)"PyScrolledWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyScrolledWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28317          { (char *)"PyScrolledWindow_swigregister", PyScrolledWindow_swigregister, METH_VARARGS, NULL},
28318          { (char *)"new_PrintData", _wrap_new_PrintData, METH_VARARGS, NULL},
28319          { (char *)"delete_PrintData", (PyCFunction) _wrap_delete_PrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28320          { (char *)"PrintData_GetNoCopies", (PyCFunction) _wrap_PrintData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28321          { (char *)"PrintData_GetCollate", (PyCFunction) _wrap_PrintData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28322          { (char *)"PrintData_GetOrientation", (PyCFunction) _wrap_PrintData_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28323          { (char *)"PrintData_Ok", (PyCFunction) _wrap_PrintData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28324          { (char *)"PrintData_GetPrinterName", (PyCFunction) _wrap_PrintData_GetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28325          { (char *)"PrintData_GetColour", (PyCFunction) _wrap_PrintData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28326          { (char *)"PrintData_GetDuplex", (PyCFunction) _wrap_PrintData_GetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28327          { (char *)"PrintData_GetPaperId", (PyCFunction) _wrap_PrintData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28328          { (char *)"PrintData_GetPaperSize", (PyCFunction) _wrap_PrintData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28329          { (char *)"PrintData_GetQuality", (PyCFunction) _wrap_PrintData_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28330          { (char *)"PrintData_GetBin", (PyCFunction) _wrap_PrintData_GetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28331          { (char *)"PrintData_GetPrintMode", (PyCFunction) _wrap_PrintData_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28332          { (char *)"PrintData_SetNoCopies", (PyCFunction) _wrap_PrintData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28333          { (char *)"PrintData_SetCollate", (PyCFunction) _wrap_PrintData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28334          { (char *)"PrintData_SetOrientation", (PyCFunction) _wrap_PrintData_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28335          { (char *)"PrintData_SetPrinterName", (PyCFunction) _wrap_PrintData_SetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28336          { (char *)"PrintData_SetColour", (PyCFunction) _wrap_PrintData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28337          { (char *)"PrintData_SetDuplex", (PyCFunction) _wrap_PrintData_SetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28338          { (char *)"PrintData_SetPaperId", (PyCFunction) _wrap_PrintData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28339          { (char *)"PrintData_SetPaperSize", (PyCFunction) _wrap_PrintData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28340          { (char *)"PrintData_SetQuality", (PyCFunction) _wrap_PrintData_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28341          { (char *)"PrintData_SetBin", (PyCFunction) _wrap_PrintData_SetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28342          { (char *)"PrintData_SetPrintMode", (PyCFunction) _wrap_PrintData_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28343          { (char *)"PrintData_GetFilename", (PyCFunction) _wrap_PrintData_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28344          { (char *)"PrintData_SetFilename", (PyCFunction) _wrap_PrintData_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28345          { (char *)"PrintData_GetPrivData", (PyCFunction) _wrap_PrintData_GetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28346          { (char *)"PrintData_SetPrivData", (PyCFunction) _wrap_PrintData_SetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28347          { (char *)"PrintData_GetPrinterCommand", (PyCFunction) _wrap_PrintData_GetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28348          { (char *)"PrintData_GetPrinterOptions", (PyCFunction) _wrap_PrintData_GetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28349          { (char *)"PrintData_GetPreviewCommand", (PyCFunction) _wrap_PrintData_GetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28350          { (char *)"PrintData_GetFontMetricPath", (PyCFunction) _wrap_PrintData_GetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28351          { (char *)"PrintData_GetPrinterScaleX", (PyCFunction) _wrap_PrintData_GetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28352          { (char *)"PrintData_GetPrinterScaleY", (PyCFunction) _wrap_PrintData_GetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28353          { (char *)"PrintData_GetPrinterTranslateX", (PyCFunction) _wrap_PrintData_GetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28354          { (char *)"PrintData_GetPrinterTranslateY", (PyCFunction) _wrap_PrintData_GetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28355          { (char *)"PrintData_SetPrinterCommand", (PyCFunction) _wrap_PrintData_SetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28356          { (char *)"PrintData_SetPrinterOptions", (PyCFunction) _wrap_PrintData_SetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28357          { (char *)"PrintData_SetPreviewCommand", (PyCFunction) _wrap_PrintData_SetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28358          { (char *)"PrintData_SetFontMetricPath", (PyCFunction) _wrap_PrintData_SetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28359          { (char *)"PrintData_SetPrinterScaleX", (PyCFunction) _wrap_PrintData_SetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28360          { (char *)"PrintData_SetPrinterScaleY", (PyCFunction) _wrap_PrintData_SetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28361          { (char *)"PrintData_SetPrinterScaling", (PyCFunction) _wrap_PrintData_SetPrinterScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28362          { (char *)"PrintData_SetPrinterTranslateX", (PyCFunction) _wrap_PrintData_SetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28363          { (char *)"PrintData_SetPrinterTranslateY", (PyCFunction) _wrap_PrintData_SetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28364          { (char *)"PrintData_SetPrinterTranslation", (PyCFunction) _wrap_PrintData_SetPrinterTranslation, METH_VARARGS | METH_KEYWORDS, NULL},
28365          { (char *)"PrintData_swigregister", PrintData_swigregister, METH_VARARGS, NULL},
28366          { (char *)"new_PageSetupDialogData", _wrap_new_PageSetupDialogData, METH_VARARGS, NULL},
28367          { (char *)"delete_PageSetupDialogData", (PyCFunction) _wrap_delete_PageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28368          { (char *)"PageSetupDialogData_EnableHelp", (PyCFunction) _wrap_PageSetupDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28369          { (char *)"PageSetupDialogData_EnableMargins", (PyCFunction) _wrap_PageSetupDialogData_EnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28370          { (char *)"PageSetupDialogData_EnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_EnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28371          { (char *)"PageSetupDialogData_EnablePaper", (PyCFunction) _wrap_PageSetupDialogData_EnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28372          { (char *)"PageSetupDialogData_EnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_EnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28373          { (char *)"PageSetupDialogData_GetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28374          { (char *)"PageSetupDialogData_GetEnableMargins", (PyCFunction) _wrap_PageSetupDialogData_GetEnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28375          { (char *)"PageSetupDialogData_GetEnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_GetEnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28376          { (char *)"PageSetupDialogData_GetEnablePaper", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28377          { (char *)"PageSetupDialogData_GetEnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28378          { (char *)"PageSetupDialogData_GetEnableHelp", (PyCFunction) _wrap_PageSetupDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28379          { (char *)"PageSetupDialogData_GetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28380          { (char *)"PageSetupDialogData_GetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28381          { (char *)"PageSetupDialogData_GetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28382          { (char *)"PageSetupDialogData_GetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28383          { (char *)"PageSetupDialogData_GetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28384          { (char *)"PageSetupDialogData_GetPaperId", (PyCFunction) _wrap_PageSetupDialogData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28385          { (char *)"PageSetupDialogData_GetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28386          { (char *)"PageSetupDialogData_GetPrintData", (PyCFunction) _wrap_PageSetupDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28387          { (char *)"PageSetupDialogData_Ok", (PyCFunction) _wrap_PageSetupDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28388          { (char *)"PageSetupDialogData_SetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28389          { (char *)"PageSetupDialogData_SetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28390          { (char *)"PageSetupDialogData_SetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28391          { (char *)"PageSetupDialogData_SetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28392          { (char *)"PageSetupDialogData_SetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28393          { (char *)"PageSetupDialogData_SetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28394          { (char *)"PageSetupDialogData_SetPaperId", (PyCFunction) _wrap_PageSetupDialogData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28395          { (char *)"PageSetupDialogData_SetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28396          { (char *)"PageSetupDialogData_SetPrintData", (PyCFunction) _wrap_PageSetupDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28397          { (char *)"PageSetupDialogData_CalculateIdFromPaperSize", (PyCFunction) _wrap_PageSetupDialogData_CalculateIdFromPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28398          { (char *)"PageSetupDialogData_CalculatePaperSizeFromId", (PyCFunction) _wrap_PageSetupDialogData_CalculatePaperSizeFromId, METH_VARARGS | METH_KEYWORDS, NULL},
28399          { (char *)"PageSetupDialogData_swigregister", PageSetupDialogData_swigregister, METH_VARARGS, NULL},
28400          { (char *)"new_PageSetupDialog", (PyCFunction) _wrap_new_PageSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28401          { (char *)"PageSetupDialog_GetPageSetupData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},
28402          { (char *)"PageSetupDialog_GetPageSetupDialogData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28403          { (char *)"PageSetupDialog_ShowModal", (PyCFunction) _wrap_PageSetupDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28404          { (char *)"PageSetupDialog_swigregister", PageSetupDialog_swigregister, METH_VARARGS, NULL},
28405          { (char *)"new_PrintDialogData", _wrap_new_PrintDialogData, METH_VARARGS, NULL},
28406          { (char *)"delete_PrintDialogData", (PyCFunction) _wrap_delete_PrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28407          { (char *)"PrintDialogData_GetFromPage", (PyCFunction) _wrap_PrintDialogData_GetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28408          { (char *)"PrintDialogData_GetToPage", (PyCFunction) _wrap_PrintDialogData_GetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28409          { (char *)"PrintDialogData_GetMinPage", (PyCFunction) _wrap_PrintDialogData_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28410          { (char *)"PrintDialogData_GetMaxPage", (PyCFunction) _wrap_PrintDialogData_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28411          { (char *)"PrintDialogData_GetNoCopies", (PyCFunction) _wrap_PrintDialogData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28412          { (char *)"PrintDialogData_GetAllPages", (PyCFunction) _wrap_PrintDialogData_GetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28413          { (char *)"PrintDialogData_GetSelection", (PyCFunction) _wrap_PrintDialogData_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28414          { (char *)"PrintDialogData_GetCollate", (PyCFunction) _wrap_PrintDialogData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28415          { (char *)"PrintDialogData_GetPrintToFile", (PyCFunction) _wrap_PrintDialogData_GetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28416          { (char *)"PrintDialogData_GetSetupDialog", (PyCFunction) _wrap_PrintDialogData_GetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28417          { (char *)"PrintDialogData_SetSetupDialog", (PyCFunction) _wrap_PrintDialogData_SetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28418          { (char *)"PrintDialogData_SetFromPage", (PyCFunction) _wrap_PrintDialogData_SetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28419          { (char *)"PrintDialogData_SetToPage", (PyCFunction) _wrap_PrintDialogData_SetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28420          { (char *)"PrintDialogData_SetMinPage", (PyCFunction) _wrap_PrintDialogData_SetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28421          { (char *)"PrintDialogData_SetMaxPage", (PyCFunction) _wrap_PrintDialogData_SetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28422          { (char *)"PrintDialogData_SetNoCopies", (PyCFunction) _wrap_PrintDialogData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28423          { (char *)"PrintDialogData_SetAllPages", (PyCFunction) _wrap_PrintDialogData_SetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28424          { (char *)"PrintDialogData_SetSelection", (PyCFunction) _wrap_PrintDialogData_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28425          { (char *)"PrintDialogData_SetCollate", (PyCFunction) _wrap_PrintDialogData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28426          { (char *)"PrintDialogData_SetPrintToFile", (PyCFunction) _wrap_PrintDialogData_SetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28427          { (char *)"PrintDialogData_EnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_EnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28428          { (char *)"PrintDialogData_EnableSelection", (PyCFunction) _wrap_PrintDialogData_EnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28429          { (char *)"PrintDialogData_EnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_EnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28430          { (char *)"PrintDialogData_EnableHelp", (PyCFunction) _wrap_PrintDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28431          { (char *)"PrintDialogData_GetEnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_GetEnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28432          { (char *)"PrintDialogData_GetEnableSelection", (PyCFunction) _wrap_PrintDialogData_GetEnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28433          { (char *)"PrintDialogData_GetEnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_GetEnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28434          { (char *)"PrintDialogData_GetEnableHelp", (PyCFunction) _wrap_PrintDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28435          { (char *)"PrintDialogData_Ok", (PyCFunction) _wrap_PrintDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28436          { (char *)"PrintDialogData_GetPrintData", (PyCFunction) _wrap_PrintDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28437          { (char *)"PrintDialogData_SetPrintData", (PyCFunction) _wrap_PrintDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28438          { (char *)"PrintDialogData_swigregister", PrintDialogData_swigregister, METH_VARARGS, NULL},
28439          { (char *)"new_PrintDialog", (PyCFunction) _wrap_new_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28440          { (char *)"PrintDialog_ShowModal", (PyCFunction) _wrap_PrintDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28441          { (char *)"PrintDialog_GetPrintDialogData", (PyCFunction) _wrap_PrintDialog_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28442          { (char *)"PrintDialog_GetPrintData", (PyCFunction) _wrap_PrintDialog_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28443          { (char *)"PrintDialog_GetPrintDC", (PyCFunction) _wrap_PrintDialog_GetPrintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28444          { (char *)"PrintDialog_swigregister", PrintDialog_swigregister, METH_VARARGS, NULL},
28445          { (char *)"new_Printer", (PyCFunction) _wrap_new_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28446          { (char *)"delete_Printer", (PyCFunction) _wrap_delete_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28447          { (char *)"Printer_CreateAbortWindow", (PyCFunction) _wrap_Printer_CreateAbortWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28448          { (char *)"Printer_ReportError", (PyCFunction) _wrap_Printer_ReportError, METH_VARARGS | METH_KEYWORDS, NULL},
28449          { (char *)"Printer_Setup", (PyCFunction) _wrap_Printer_Setup, METH_VARARGS | METH_KEYWORDS, NULL},
28450          { (char *)"Printer_Print", (PyCFunction) _wrap_Printer_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28451          { (char *)"Printer_PrintDialog", (PyCFunction) _wrap_Printer_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28452          { (char *)"Printer_GetPrintDialogData", (PyCFunction) _wrap_Printer_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28453          { (char *)"Printer_GetAbort", (PyCFunction) _wrap_Printer_GetAbort, METH_VARARGS | METH_KEYWORDS, NULL},
28454          { (char *)"Printer_GetLastError", (PyCFunction) _wrap_Printer_GetLastError, METH_VARARGS | METH_KEYWORDS, NULL},
28455          { (char *)"Printer_swigregister", Printer_swigregister, METH_VARARGS, NULL},
28456          { (char *)"new_Printout", (PyCFunction) _wrap_new_Printout, METH_VARARGS | METH_KEYWORDS, NULL},
28457          { (char *)"Printout__setCallbackInfo", (PyCFunction) _wrap_Printout__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28458          { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28459          { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28460          { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28461          { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28462          { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28463          { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28464          { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28465          { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28466          { (char *)"Printout_GetPPIScreen", (PyCFunction) _wrap_Printout_GetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28467          { (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28468          { (char *)"Printout_GetPPIPrinter", (PyCFunction) _wrap_Printout_GetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28469          { (char *)"Printout_IsPreview", (PyCFunction) _wrap_Printout_IsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28470          { (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28471          { (char *)"Printout_base_OnBeginDocument", (PyCFunction) _wrap_Printout_base_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28472          { (char *)"Printout_base_OnEndDocument", (PyCFunction) _wrap_Printout_base_OnEndDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28473          { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28474          { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28475          { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28476          { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS, NULL},
28477          { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28478          { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS, NULL},
28479          { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28480          { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS, NULL},
28481          { (char *)"new_PreviewFrame", (PyCFunction) _wrap_new_PreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28482          { (char *)"PreviewFrame_Initialize", (PyCFunction) _wrap_PreviewFrame_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28483          { (char *)"PreviewFrame_CreateControlBar", (PyCFunction) _wrap_PreviewFrame_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28484          { (char *)"PreviewFrame_CreateCanvas", (PyCFunction) _wrap_PreviewFrame_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28485          { (char *)"PreviewFrame_GetControlBar", (PyCFunction) _wrap_PreviewFrame_GetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28486          { (char *)"PreviewFrame_swigregister", PreviewFrame_swigregister, METH_VARARGS, NULL},
28487          { (char *)"new_PreviewControlBar", (PyCFunction) _wrap_new_PreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28488          { (char *)"PreviewControlBar_GetZoomControl", (PyCFunction) _wrap_PreviewControlBar_GetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28489          { (char *)"PreviewControlBar_SetZoomControl", (PyCFunction) _wrap_PreviewControlBar_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28490          { (char *)"PreviewControlBar_GetPrintPreview", (PyCFunction) _wrap_PreviewControlBar_GetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28491          { (char *)"PreviewControlBar_OnNext", (PyCFunction) _wrap_PreviewControlBar_OnNext, METH_VARARGS | METH_KEYWORDS, NULL},
28492          { (char *)"PreviewControlBar_OnPrevious", (PyCFunction) _wrap_PreviewControlBar_OnPrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28493          { (char *)"PreviewControlBar_OnFirst", (PyCFunction) _wrap_PreviewControlBar_OnFirst, METH_VARARGS | METH_KEYWORDS, NULL},
28494          { (char *)"PreviewControlBar_OnLast", (PyCFunction) _wrap_PreviewControlBar_OnLast, METH_VARARGS | METH_KEYWORDS, NULL},
28495          { (char *)"PreviewControlBar_OnGoto", (PyCFunction) _wrap_PreviewControlBar_OnGoto, METH_VARARGS | METH_KEYWORDS, NULL},
28496          { (char *)"PreviewControlBar_swigregister", PreviewControlBar_swigregister, METH_VARARGS, NULL},
28497          { (char *)"new_PrintPreview", _wrap_new_PrintPreview, METH_VARARGS, NULL},
28498          { (char *)"PrintPreview_SetCurrentPage", (PyCFunction) _wrap_PrintPreview_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28499          { (char *)"PrintPreview_GetCurrentPage", (PyCFunction) _wrap_PrintPreview_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28500          { (char *)"PrintPreview_SetPrintout", (PyCFunction) _wrap_PrintPreview_SetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28501          { (char *)"PrintPreview_GetPrintout", (PyCFunction) _wrap_PrintPreview_GetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28502          { (char *)"PrintPreview_GetPrintoutForPrinting", (PyCFunction) _wrap_PrintPreview_GetPrintoutForPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28503          { (char *)"PrintPreview_SetFrame", (PyCFunction) _wrap_PrintPreview_SetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28504          { (char *)"PrintPreview_SetCanvas", (PyCFunction) _wrap_PrintPreview_SetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28505          { (char *)"PrintPreview_GetFrame", (PyCFunction) _wrap_PrintPreview_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28506          { (char *)"PrintPreview_GetCanvas", (PyCFunction) _wrap_PrintPreview_GetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28507          { (char *)"PrintPreview_PaintPage", (PyCFunction) _wrap_PrintPreview_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28508          { (char *)"PrintPreview_DrawBlankPage", (PyCFunction) _wrap_PrintPreview_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28509          { (char *)"PrintPreview_RenderPage", (PyCFunction) _wrap_PrintPreview_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28510          { (char *)"PrintPreview_AdjustScrollbars", (PyCFunction) _wrap_PrintPreview_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
28511          { (char *)"PrintPreview_GetPrintDialogData", (PyCFunction) _wrap_PrintPreview_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28512          { (char *)"PrintPreview_SetZoom", (PyCFunction) _wrap_PrintPreview_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28513          { (char *)"PrintPreview_GetZoom", (PyCFunction) _wrap_PrintPreview_GetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28514          { (char *)"PrintPreview_GetMaxPage", (PyCFunction) _wrap_PrintPreview_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28515          { (char *)"PrintPreview_GetMinPage", (PyCFunction) _wrap_PrintPreview_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28516          { (char *)"PrintPreview_Ok", (PyCFunction) _wrap_PrintPreview_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28517          { (char *)"PrintPreview_SetOk", (PyCFunction) _wrap_PrintPreview_SetOk, METH_VARARGS | METH_KEYWORDS, NULL},
28518          { (char *)"PrintPreview_Print", (PyCFunction) _wrap_PrintPreview_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28519          { (char *)"PrintPreview_DetermineScaling", (PyCFunction) _wrap_PrintPreview_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28520          { (char *)"PrintPreview_swigregister", PrintPreview_swigregister, METH_VARARGS, NULL},
28521          { (char *)"new_PyPrintPreview", _wrap_new_PyPrintPreview, METH_VARARGS, NULL},
28522          { (char *)"PyPrintPreview__setCallbackInfo", (PyCFunction) _wrap_PyPrintPreview__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28523          { (char *)"PyPrintPreview_base_SetCurrentPage", (PyCFunction) _wrap_PyPrintPreview_base_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28524          { (char *)"PyPrintPreview_base_PaintPage", (PyCFunction) _wrap_PyPrintPreview_base_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28525          { (char *)"PyPrintPreview_base_DrawBlankPage", (PyCFunction) _wrap_PyPrintPreview_base_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28526          { (char *)"PyPrintPreview_base_RenderPage", (PyCFunction) _wrap_PyPrintPreview_base_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28527          { (char *)"PyPrintPreview_base_SetZoom", (PyCFunction) _wrap_PyPrintPreview_base_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28528          { (char *)"PyPrintPreview_base_Print", (PyCFunction) _wrap_PyPrintPreview_base_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28529          { (char *)"PyPrintPreview_base_DetermineScaling", (PyCFunction) _wrap_PyPrintPreview_base_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28530          { (char *)"PyPrintPreview_swigregister", PyPrintPreview_swigregister, METH_VARARGS, NULL},
28531          { (char *)"new_PyPreviewFrame", (PyCFunction) _wrap_new_PyPreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28532          { (char *)"PyPreviewFrame__setCallbackInfo", (PyCFunction) _wrap_PyPreviewFrame__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28533          { (char *)"PyPreviewFrame_SetPreviewCanvas", (PyCFunction) _wrap_PyPreviewFrame_SetPreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28534          { (char *)"PyPreviewFrame_SetControlBar", (PyCFunction) _wrap_PyPreviewFrame_SetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28535          { (char *)"PyPreviewFrame_base_Initialize", (PyCFunction) _wrap_PyPreviewFrame_base_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28536          { (char *)"PyPreviewFrame_base_CreateCanvas", (PyCFunction) _wrap_PyPreviewFrame_base_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28537          { (char *)"PyPreviewFrame_base_CreateControlBar", (PyCFunction) _wrap_PyPreviewFrame_base_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28538          { (char *)"PyPreviewFrame_swigregister", PyPreviewFrame_swigregister, METH_VARARGS, NULL},
28539          { (char *)"new_PyPreviewControlBar", (PyCFunction) _wrap_new_PyPreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28540          { (char *)"PyPreviewControlBar__setCallbackInfo", (PyCFunction) _wrap_PyPreviewControlBar__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28541          { (char *)"PyPreviewControlBar_SetPrintPreview", (PyCFunction) _wrap_PyPreviewControlBar_SetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28542          { (char *)"PyPreviewControlBar_base_CreateButtons", (PyCFunction) _wrap_PyPreviewControlBar_base_CreateButtons, METH_VARARGS | METH_KEYWORDS, NULL},
28543          { (char *)"PyPreviewControlBar_base_SetZoomControl", (PyCFunction) _wrap_PyPreviewControlBar_base_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28544          { (char *)"PyPreviewControlBar_swigregister", PyPreviewControlBar_swigregister, METH_VARARGS, NULL},
28545          { NULL, NULL, 0, NULL }
28546 };
28547
28548
28549 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28550
28551 static void *_p_wxPyPreviewFrameTo_p_wxPreviewFrame(void *x) {
28552     return (void *)((wxPreviewFrame *)  ((wxPyPreviewFrame *) x));
28553 }
28554 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
28555     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
28556 }
28557 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
28558     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
28559 }
28560 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
28561     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
28562 }
28563 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
28564     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
28565 }
28566 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
28567     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
28568 }
28569 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
28570     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
28571 }
28572 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
28573     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28574 }
28575 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
28576     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
28577 }
28578 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
28579     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
28580 }
28581 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
28582     return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
28583 }
28584 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
28585     return (void *)((wxEvent *)  ((wxPyEvent *) x));
28586 }
28587 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
28588     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
28589 }
28590 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
28591     return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
28592 }
28593 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
28594     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
28595 }
28596 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
28597     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
28598 }
28599 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
28600     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
28601 }
28602 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
28603     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
28604 }
28605 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
28606     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
28607 }
28608 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
28609     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
28610 }
28611 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
28612     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
28613 }
28614 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
28615     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
28616 }
28617 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
28618     return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
28619 }
28620 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
28621     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
28622 }
28623 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
28624     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
28625 }
28626 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
28627     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
28628 }
28629 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
28630     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
28631 }
28632 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
28633     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
28634 }
28635 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
28636     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
28637 }
28638 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
28639     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
28640 }
28641 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
28642     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
28643 }
28644 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
28645     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
28646 }
28647 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
28648     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
28649 }
28650 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
28651     return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
28652 }
28653 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
28654     return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
28655 }
28656 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
28657     return (void *)((wxEvent *)  ((wxShowEvent *) x));
28658 }
28659 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
28660     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
28661 }
28662 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
28663     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
28664 }
28665 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
28666     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28667 }
28668 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
28669     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
28670 }
28671 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
28672     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
28673 }
28674 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
28675     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
28676 }
28677 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
28678     return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
28679 }
28680 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
28681     return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
28682 }
28683 static void *_p_wxPasswordEntryDialogTo_p_wxTextEntryDialog(void *x) {
28684     return (void *)((wxTextEntryDialog *)  ((wxPasswordEntryDialog *) x));
28685 }
28686 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
28687     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28688 }
28689 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
28690     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28691 }
28692 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
28693     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28694 }
28695 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
28696     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
28697 }
28698 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
28699     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
28700 }
28701 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
28702     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
28703 }
28704 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
28705     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
28706 }
28707 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
28708     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28709 }
28710 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
28711     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28712 }
28713 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
28714     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28715 }
28716 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
28717     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28718 }
28719 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
28720     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28721 }
28722 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
28723     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28724 }
28725 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
28726     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28727 }
28728 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
28729     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28730 }
28731 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
28732     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
28733 }
28734 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
28735     return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
28736 }
28737 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
28738     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28739 }
28740 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
28741     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
28742 }
28743 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
28744     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28745 }
28746 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
28747     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
28748 }
28749 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
28750     return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28751 }
28752 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
28753     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
28754 }
28755 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
28756     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
28757 }
28758 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
28759     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
28760 }
28761 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
28762     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
28763 }
28764 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
28765     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28766 }
28767 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
28768     return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
28769 }
28770 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
28771     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
28772 }
28773 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
28774     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28775 }
28776 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
28777     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
28778 }
28779 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
28780     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28781 }
28782 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
28783     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28784 }
28785 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
28786     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28787 }
28788 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
28789     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
28790 }
28791 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
28792     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
28793 }
28794 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
28795     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
28796 }
28797 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
28798     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28799 }
28800 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
28801     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28802 }
28803 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
28804     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28805 }
28806 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
28807     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
28808 }
28809 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
28810     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
28811 }
28812 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
28813     return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
28814 }
28815 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
28816     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28817 }
28818 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
28819     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
28820 }
28821 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
28822     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
28823 }
28824 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
28825     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
28826 }
28827 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
28828     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
28829 }
28830 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
28831     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28832 }
28833 static void *_p_wxPyHtmlListBoxTo_p_wxPyVListBox(void *x) {
28834     return (void *)((wxPyVListBox *)  ((wxPyHtmlListBox *) x));
28835 }
28836 static void *_p_wxMDIChildFrameTo_p_wxFrame(void *x) {
28837     return (void *)((wxFrame *)  ((wxMDIChildFrame *) x));
28838 }
28839 static void *_p_wxProgressDialogTo_p_wxFrame(void *x) {
28840     return (void *)((wxFrame *)  ((wxProgressDialog *) x));
28841 }
28842 static void *_p_wxPreviewFrameTo_p_wxFrame(void *x) {
28843     return (void *)((wxFrame *)  ((wxPreviewFrame *) x));
28844 }
28845 static void *_p_wxPyPreviewFrameTo_p_wxFrame(void *x) {
28846     return (void *)((wxFrame *) (wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28847 }
28848 static void *_p_wxMiniFrameTo_p_wxFrame(void *x) {
28849     return (void *)((wxFrame *)  ((wxMiniFrame *) x));
28850 }
28851 static void *_p_wxSplashScreenTo_p_wxFrame(void *x) {
28852     return (void *)((wxFrame *)  ((wxSplashScreen *) x));
28853 }
28854 static void *_p_wxMDIParentFrameTo_p_wxFrame(void *x) {
28855     return (void *)((wxFrame *)  ((wxMDIParentFrame *) x));
28856 }
28857 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28858     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
28859 }
28860 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
28861     return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
28862 }
28863 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
28864     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28865 }
28866 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
28867     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28868 }
28869 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28870     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28871 }
28872 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28873     return (void *)((wxObject *)  ((wxSizerItem *) x));
28874 }
28875 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28876     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28877 }
28878 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28879     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
28880 }
28881 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28882     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28883 }
28884 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28885     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28886 }
28887 static void *_p_wxSizerTo_p_wxObject(void *x) {
28888     return (void *)((wxObject *)  ((wxSizer *) x));
28889 }
28890 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28891     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28892 }
28893 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28894     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28895 }
28896 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
28897     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28898 }
28899 static void *_p_wxEventTo_p_wxObject(void *x) {
28900     return (void *)((wxObject *)  ((wxEvent *) x));
28901 }
28902 static void *_p_wxFontDataTo_p_wxObject(void *x) {
28903     return (void *)((wxObject *)  ((wxFontData *) x));
28904 }
28905 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
28906     return (void *)((wxObject *)  ((wxPrintData *) x));
28907 }
28908 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28909     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28910 }
28911 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28912     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28913 }
28914 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28915     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28916 }
28917 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
28918     return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
28919 }
28920 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
28921     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
28922 }
28923 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
28924     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
28925 }
28926 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28927     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28928 }
28929 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28930     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28931 }
28932 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28933     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28934 }
28935 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28936     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28937 }
28938 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28939     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28940 }
28941 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28942     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28943 }
28944 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
28945     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28946 }
28947 static void *_p_wxControlTo_p_wxObject(void *x) {
28948     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28949 }
28950 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28951     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28952 }
28953 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
28954     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28955 }
28956 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28957     return (void *)((wxObject *)  ((wxFSFile *) x));
28958 }
28959 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
28960     return (void *)((wxObject *)  ((wxFindReplaceData *) x));
28961 }
28962 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28963     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28964 }
28965 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
28966     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28967 }
28968 static void *_p_wxColourDataTo_p_wxObject(void *x) {
28969     return (void *)((wxObject *)  ((wxColourData *) x));
28970 }
28971 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28972     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28973 }
28974 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28975     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28976 }
28977 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
28978     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
28979 }
28980 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
28981     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28982 }
28983 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
28984     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28985 }
28986 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
28987     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28988 }
28989 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
28990     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28991 }
28992 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
28993     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28994 }
28995 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
28996     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28997 }
28998 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
28999     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29000 }
29001 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
29002     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29003 }
29004 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
29005     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29006 }
29007 static void *_p_wxShowEventTo_p_wxObject(void *x) {
29008     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
29009 }
29010 static void *_p_wxPrinterTo_p_wxObject(void *x) {
29011     return (void *)((wxObject *)  ((wxPrinter *) x));
29012 }
29013 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
29014     return (void *)((wxObject *)  ((wxMenuItem *) x));
29015 }
29016 static void *_p_wxDateEventTo_p_wxObject(void *x) {
29017     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
29018 }
29019 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
29020     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
29021 }
29022 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
29023     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
29024 }
29025 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
29026     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
29027 }
29028 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
29029     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
29030 }
29031 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
29032     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
29033 }
29034 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
29035     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
29036 }
29037 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
29038     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
29039 }
29040 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
29041     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
29042 }
29043 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
29044     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
29045 }
29046 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
29047     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
29048 }
29049 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
29050     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
29051 }
29052 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
29053     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
29054 }
29055 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
29056     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
29057 }
29058 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
29059     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
29060 }
29061 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
29062     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
29063 }
29064 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
29065     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
29066 }
29067 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
29068     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
29069 }
29070 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
29071     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
29072 }
29073 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
29074     return (void *)((wxObject *)  ((wxImageHandler *) x));
29075 }
29076 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
29077     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
29078 }
29079 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
29080     return (void *)((wxObject *)  ((wxEvtHandler *) x));
29081 }
29082 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
29083     return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
29084 }
29085 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
29086     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29087 }
29088 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
29089     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29090 }
29091 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
29092     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
29093 }
29094 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
29095     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
29096 }
29097 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
29098     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29099 }
29100 static void *_p_wxImageTo_p_wxObject(void *x) {
29101     return (void *)((wxObject *)  ((wxImage *) x));
29102 }
29103 static void *_p_wxFrameTo_p_wxObject(void *x) {
29104     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
29105 }
29106 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
29107     return (void *)((wxObject *)  ((wxPyPrintout *) x));
29108 }
29109 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
29110     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
29111 }
29112 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
29113     return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
29114 }
29115 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
29116     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
29117 }
29118 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
29119     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29120 }
29121 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
29122     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
29123 }
29124 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
29125     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
29126 }
29127 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
29128     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
29129 }
29130 static void *_p_wxWindowTo_p_wxObject(void *x) {
29131     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
29132 }
29133 static void *_p_wxMenuTo_p_wxObject(void *x) {
29134     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
29135 }
29136 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
29137     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
29138 }
29139 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
29140     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
29141 }
29142 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
29143     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
29144 }
29145 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
29146     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
29147 }
29148 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
29149     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
29150 }
29151 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
29152     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
29153 }
29154 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
29155     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
29156 }
29157 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
29158     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
29159 }
29160 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
29161     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29162 }
29163 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
29164     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29165 }
29166 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
29167     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
29168 }
29169 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
29170     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
29171 }
29172 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
29173     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29174 }
29175 static void *_p_wxSashEventTo_p_wxObject(void *x) {
29176     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
29177 }
29178 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
29179     return (void *)((wxObject *)  ((wxPrintPreview *) x));
29180 }
29181 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
29182     return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
29183 }
29184 static void *_p_wxPanelTo_p_wxObject(void *x) {
29185     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
29186 }
29187 static void *_p_wxDialogTo_p_wxObject(void *x) {
29188     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
29189 }
29190 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
29191     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29192 }
29193 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
29194     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29195 }
29196 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
29197     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29198 }
29199 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
29200     return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
29201 }
29202 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
29203     return (void *)((wxObject *)  ((wxPrintDialog *) x));
29204 }
29205 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29206     return (void *)((wxObject *)  ((wxFileSystem *) x));
29207 }
29208 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29209     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29210 }
29211 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29212     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29213 }
29214 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29215     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29216 }
29217 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29218     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29219 }
29220 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29221     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29222 }
29223 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29224     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29225 }
29226 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29227     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29228 }
29229 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29230     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29231 }
29232 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
29233     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
29234 }
29235 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
29236     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29237 }
29238 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29239     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29240 }
29241 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29242     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29243 }
29244 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29245     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29246 }
29247 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29248     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29249 }
29250 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
29251     return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
29252 }
29253 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
29254     return (void *)((wxObject *)  ((wxPrintDialogData *) x));
29255 }
29256 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29257     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29258 }
29259 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29260     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29261 }
29262 static void *_p_wxPyVListBoxTo_p_wxPyVScrolledWindow(void *x) {
29263     return (void *)((wxPyVScrolledWindow *)  ((wxPyVListBox *) x));
29264 }
29265 static void *_p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow(void *x) {
29266     return (void *)((wxPyVScrolledWindow *) (wxPyVListBox *) ((wxPyHtmlListBox *) x));
29267 }
29268 static void *_p_wxTipWindowTo_p_wxPyPopupTransientWindow(void *x) {
29269     return (void *)((wxPyPopupTransientWindow *)  ((wxTipWindow *) x));
29270 }
29271 static void *_p_wxPyPopupTransientWindowTo_p_wxPopupWindow(void *x) {
29272     return (void *)((wxPopupWindow *)  ((wxPyPopupTransientWindow *) x));
29273 }
29274 static void *_p_wxTipWindowTo_p_wxPopupWindow(void *x) {
29275     return (void *)((wxPopupWindow *) (wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29276 }
29277 static void *_p_wxSashLayoutWindowTo_p_wxSashWindow(void *x) {
29278     return (void *)((wxSashWindow *)  ((wxSashLayoutWindow *) x));
29279 }
29280 static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
29281     return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
29282 }
29283 static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
29284     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
29285 }
29286 static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
29287     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
29288 }
29289 static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
29290     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
29291 }
29292 static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
29293     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
29294 }
29295 static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
29296     return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
29297 }
29298 static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
29299     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
29300 }
29301 static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
29302     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
29303 }
29304 static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
29305     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
29306 }
29307 static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
29308     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxProgressDialog *) x));
29309 }
29310 static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
29311     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
29312 }
29313 static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
29314     return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29315 }
29316 static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
29317     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
29318 }
29319 static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29320     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
29321 }
29322 static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29323     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
29324 }
29325 static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
29326     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
29327 }
29328 static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
29329     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
29330 }
29331 static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29332     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
29333 }
29334 static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29335     return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29336 }
29337 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
29338     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
29339 }
29340 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
29341     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29342 }
29343 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
29344     return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
29345 }
29346 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29347     return (void *)((wxWindow *)  ((wxMenuBar *) x));
29348 }
29349 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
29350     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29351 }
29352 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
29353     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29354 }
29355 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
29356     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29357 }
29358 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
29359     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29360 }
29361 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
29362     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
29363 }
29364 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
29365     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
29366 }
29367 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
29368     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
29369 }
29370 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
29371     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
29372 }
29373 static void *_p_wxPanelTo_p_wxWindow(void *x) {
29374     return (void *)((wxWindow *)  ((wxPanel *) x));
29375 }
29376 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
29377     return (void *)((wxWindow *)  ((wxStatusBar *) x));
29378 }
29379 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
29380     return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
29381 }
29382 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
29383     return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29384 }
29385 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
29386     return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29387 }
29388 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
29389     return (void *)((wxWindow *)  ((wxPopupWindow *) x));
29390 }
29391 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
29392     return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
29393 }
29394 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
29395     return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
29396 }
29397 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
29398     return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
29399 }
29400 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
29401     return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
29402 }
29403 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
29404     return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
29405 }
29406 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
29407     return (void *)((wxWindow *)  ((wxSashWindow *) x));
29408 }
29409 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
29410     return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
29411 }
29412 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
29413     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29414 }
29415 static void *_p_wxControlTo_p_wxWindow(void *x) {
29416     return (void *)((wxWindow *)  ((wxControl *) x));
29417 }
29418 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
29419     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
29420 }
29421 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
29422     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29423 }
29424 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
29425     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
29426 }
29427 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29428     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29429 }
29430 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
29431     return (void *)((wxWindow *)  ((wxPyWindow *) x));
29432 }
29433 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
29434     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
29435 }
29436 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
29437     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29438 }
29439 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
29440     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29441 }
29442 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
29443     return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
29444 }
29445 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
29446     return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29447 }
29448 static void *_p_wxFrameTo_p_wxWindow(void *x) {
29449     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
29450 }
29451 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
29452     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29453 }
29454 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
29455     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29456 }
29457 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
29458     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29459 }
29460 static void *_p_wxDialogTo_p_wxWindow(void *x) {
29461     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
29462 }
29463 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
29464     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29465 }
29466 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
29467     return (void *)((wxScrolledWindow *)  ((wxPyScrolledWindow *) x));
29468 }
29469 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
29470     return (void *)((wxScrolledWindow *)  ((wxPreviewCanvas *) x));
29471 }
29472 static void *_p_wxPyPrintPreviewTo_p_wxPrintPreview(void *x) {
29473     return (void *)((wxPrintPreview *)  ((wxPyPrintPreview *) x));
29474 }
29475 static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
29476     return (void *)((wxDialog *)  ((wxColourDialog *) x));
29477 }
29478 static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
29479     return (void *)((wxDialog *)  ((wxDirDialog *) x));
29480 }
29481 static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
29482     return (void *)((wxDialog *)  ((wxFontDialog *) x));
29483 }
29484 static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
29485     return (void *)((wxDialog *)  ((wxFileDialog *) x));
29486 }
29487 static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
29488     return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
29489 }
29490 static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
29491     return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
29492 }
29493 static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
29494     return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
29495 }
29496 static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
29497     return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29498 }
29499 static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
29500     return (void *)((wxDialog *)  ((wxMessageDialog *) x));
29501 }
29502 static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
29503     return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
29504 }
29505 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
29506     return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
29507 }
29508 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
29509     return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
29510 }
29511 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
29512     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29513 }
29514 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
29515     return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29516 }
29517 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
29518     return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29519 }
29520 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
29521     return (void *)((wxPanel *)  ((wxPyPanel *) x));
29522 }
29523 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
29524     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
29525 }
29526 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
29527     return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
29528 }
29529 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
29530     return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29531 }
29532 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
29533     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
29534 }
29535 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
29536     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
29537 }
29538 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
29539     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
29540 }
29541 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
29542     return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
29543 }
29544 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
29545     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
29546 }
29547 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
29548     return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
29549 }
29550 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
29551     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
29552 }
29553 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
29554     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
29555 }
29556 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
29557     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
29558 }
29559 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
29560     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
29561 }
29562 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
29563     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
29564 }
29565 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
29566     return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
29567 }
29568 static void *_p_wxPyPreviewControlBarTo_p_wxPreviewControlBar(void *x) {
29569     return (void *)((wxPreviewControlBar *)  ((wxPyPreviewControlBar *) x));
29570 }
29571 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent[] = {{"_p_wxQueryLayoutInfoEvent", 0, "wxQueryLayoutInfoEvent *", 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29572 static swig_type_info _swigt__p_wxPreviewFrame[] = {{"_p_wxPreviewFrame", 0, "wxPreviewFrame *", 0, 0, 0, 0},{"_p_wxPreviewFrame", 0, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxPreviewFrame, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29573 static swig_type_info _swigt__p_wxPyPreviewFrame[] = {{"_p_wxPyPreviewFrame", 0, "wxPyPreviewFrame *", 0, 0, 0, 0},{"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29574 static swig_type_info _swigt__p_wxPyPanel[] = {{"_p_wxPyPanel", 0, "wxPyPanel *", 0, 0, 0, 0},{"_p_wxPyPanel", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29575 static swig_type_info _swigt__p_wxMenu[] = {{"_p_wxMenu", 0, "wxMenu *", 0, 0, 0, 0},{"_p_wxMenu", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29576 static swig_type_info _swigt__p_wxFontData[] = {{"_p_wxFontData", 0, "wxFontData *", 0, 0, 0, 0},{"_p_wxFontData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29577 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_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_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_wxDateEvent", _p_wxDateEventTo_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_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_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_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_wxSashEvent", _p_wxSashEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_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_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29578 static swig_type_info _swigt__p_wxPrintData[] = {{"_p_wxPrintData", 0, "wxPrintData *", 0, 0, 0, 0},{"_p_wxPrintData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29579 static swig_type_info _swigt__p_wxTaskBarIcon[] = {{"_p_wxTaskBarIcon", 0, "wxTaskBarIcon *", 0, 0, 0, 0},{"_p_wxTaskBarIcon", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29580 static swig_type_info _swigt__p_wxPyTaskBarIcon[] = {{"_p_wxPyTaskBarIcon", 0, "wxPyTaskBarIcon *", 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29581 static swig_type_info _swigt__p_wxIconBundle[] = {{"_p_wxIconBundle", 0, "wxIconBundle *", 0, 0, 0, 0},{"_p_wxIconBundle", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29582 static swig_type_info _swigt__p_wxLayoutAlgorithm[] = {{"_p_wxLayoutAlgorithm", 0, "wxLayoutAlgorithm *", 0, 0, 0, 0},{"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29583 static swig_type_info _swigt__p_wxFindDialogEvent[] = {{"_p_wxFindDialogEvent", 0, "wxFindDialogEvent *", 0, 0, 0, 0},{"_p_wxFindDialogEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29584 static swig_type_info _swigt__p_wxPreviewCanvas[] = {{"_p_wxPreviewCanvas", 0, "wxPreviewCanvas *", 0, 0, 0, 0},{"_p_wxPreviewCanvas", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29585 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}};
29586 static swig_type_info _swigt__p_wxSplitterEvent[] = {{"_p_wxSplitterEvent", 0, "wxSplitterEvent *", 0, 0, 0, 0},{"_p_wxSplitterEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29587 static swig_type_info _swigt__p_wxRegion[] = {{"_p_wxRegion", 0, "wxRegion *", 0, 0, 0, 0},{"_p_wxRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29588 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}};
29589 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}};
29590 static swig_type_info _swigt__p_wxFindReplaceData[] = {{"_p_wxFindReplaceData", 0, "wxFindReplaceData *", 0, 0, 0, 0},{"_p_wxFindReplaceData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29591 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}};
29592 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}};
29593 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}};
29594 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}};
29595 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}};
29596 static swig_type_info _swigt__p_wxMDIChildFrame[] = {{"_p_wxMDIChildFrame", 0, "wxMDIChildFrame *", 0, 0, 0, 0},{"_p_wxMDIChildFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29597 static swig_type_info _swigt__p_wxColourData[] = {{"_p_wxColourData", 0, "wxColourData *", 0, 0, 0, 0},{"_p_wxColourData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29598 static swig_type_info _swigt__p_wxNotifyEvent[] = {{"_p_wxNotifyEvent", 0, "wxNotifyEvent *", 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29599 static swig_type_info _swigt__p_wxPyWindow[] = {{"_p_wxPyWindow", 0, "wxPyWindow *", 0, 0, 0, 0},{"_p_wxPyWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29600 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}};
29601 static swig_type_info _swigt__p_wxSplashScreen[] = {{"_p_wxSplashScreen", 0, "wxSplashScreen *", 0, 0, 0, 0},{"_p_wxSplashScreen", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29602 static swig_type_info _swigt__p_wxPasswordEntryDialog[] = {{"_p_wxPasswordEntryDialog", 0, "wxPasswordEntryDialog *", 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29603 static swig_type_info _swigt__p_wxSingleChoiceDialog[] = {{"_p_wxSingleChoiceDialog", 0, "wxSingleChoiceDialog *", 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29604 static swig_type_info _swigt__p_wxMultiChoiceDialog[] = {{"_p_wxMultiChoiceDialog", 0, "wxMultiChoiceDialog *", 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29605 static swig_type_info _swigt__p_wxFileDialog[] = {{"_p_wxFileDialog", 0, "wxFileDialog *", 0, 0, 0, 0},{"_p_wxFileDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29606 static swig_type_info _swigt__p_wxTextEntryDialog[] = {{"_p_wxTextEntryDialog", 0, "wxTextEntryDialog *", 0, 0, 0, 0},{"_p_wxTextEntryDialog", 0, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxTextEntryDialog, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29607 static swig_type_info _swigt__p_wxMessageDialog[] = {{"_p_wxMessageDialog", 0, "wxMessageDialog *", 0, 0, 0, 0},{"_p_wxMessageDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29608 static swig_type_info _swigt__p_wxProgressDialog[] = {{"_p_wxProgressDialog", 0, "wxProgressDialog *", 0, 0, 0, 0},{"_p_wxProgressDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29609 static swig_type_info _swigt__p_wxFindReplaceDialog[] = {{"_p_wxFindReplaceDialog", 0, "wxFindReplaceDialog *", 0, 0, 0, 0},{"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29610 static swig_type_info _swigt__p_wxPrinter[] = {{"_p_wxPrinter", 0, "wxPrinter *", 0, 0, 0, 0},{"_p_wxPrinter", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29611 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}};
29612 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}};
29613 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_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_wxMessageDialog", _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29614 static swig_type_info _swigt__p_wxCalculateLayoutEvent[] = {{"_p_wxCalculateLayoutEvent", 0, "wxCalculateLayoutEvent *", 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29615 static swig_type_info _swigt__p_wxPyHtmlListBox[] = {{"_p_wxPyHtmlListBox", 0, "wxPyHtmlListBox *", 0, 0, 0, 0},{"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29616 static swig_type_info _swigt__p_wxPyVListBox[] = {{"_p_wxPyVListBox", 0, "wxPyVListBox *", 0, 0, 0, 0},{"_p_wxPyVListBox", 0, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxPyVListBox, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29617 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}};
29618 static swig_type_info _swigt__p_wxStdDialogButtonSizer[] = {{"_p_wxStdDialogButtonSizer", 0, "wxStdDialogButtonSizer *", 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29619 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}};
29620 static swig_type_info _swigt__p_wxMiniFrame[] = {{"_p_wxMiniFrame", 0, "wxMiniFrame *", 0, 0, 0, 0},{"_p_wxMiniFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29621 static swig_type_info _swigt__p_wxFrame[] = {{"_p_wxFrame", 0, "wxFrame *", 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxFrame", 0, 0, 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxFrame, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxFrame, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29622 static swig_type_info _swigt__p_wxPyPrintout[] = {{"_p_wxPyPrintout", 0, "wxPyPrintout *", 0, 0, 0, 0},{"_p_wxPyPrintout", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29623 static swig_type_info _swigt__p_wxTaskBarIconEvent[] = {{"_p_wxTaskBarIconEvent", 0, "wxTaskBarIconEvent *", 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29624 static swig_type_info _swigt__p_wxScrollWinEvent[] = {{"_p_wxScrollWinEvent", 0, "wxScrollWinEvent *", 0, 0, 0, 0},{"_p_wxScrollWinEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29625 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}};
29626 static swig_type_info _swigt__p_wxStatusBar[] = {{"_p_wxStatusBar", 0, "wxStatusBar *", 0, 0, 0, 0},{"_p_wxStatusBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29627 static swig_type_info _swigt__p_wxMDIParentFrame[] = {{"_p_wxMDIParentFrame", 0, "wxMDIParentFrame *", 0, 0, 0, 0},{"_p_wxMDIParentFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29628 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}};
29629 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxQueryLayoutInfoEvent", _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontData", _p_wxFontDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintData", _p_wxPrintDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTaskBarIcon", _p_wxPyTaskBarIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxLayoutAlgorithm", _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_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_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceData", _p_wxFindReplaceDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourData", _p_wxColourDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinter", _p_wxPrinterTo_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_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCalculateLayoutEvent", _p_wxCalculateLayoutEventTo_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_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_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_wxMiniFrame", _p_wxMiniFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintout", _p_wxPyPrintoutTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTaskBarIconEvent", _p_wxTaskBarIconEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_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_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintPreview", _p_wxPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPrintPreview", _p_wxPyPrintPreviewTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialog", _p_wxPageSetupDialogTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialog", _p_wxPrintDialogTo_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_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_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPageSetupDialogData", _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrintDialogData", _p_wxPrintDialogDataTo_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}};
29630 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}};
29631 static swig_type_info _swigt__p_wxTipWindow[] = {{"_p_wxTipWindow", 0, "wxTipWindow *", 0, 0, 0, 0},{"_p_wxTipWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29632 static swig_type_info _swigt__p_wxSashLayoutWindow[] = {{"_p_wxSashLayoutWindow", 0, "wxSashLayoutWindow *", 0, 0, 0, 0},{"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29633 static swig_type_info _swigt__p_wxSplitterWindow[] = {{"_p_wxSplitterWindow", 0, "wxSplitterWindow *", 0, 0, 0, 0},{"_p_wxSplitterWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29634 static swig_type_info _swigt__p_wxSplashScreenWindow[] = {{"_p_wxSplashScreenWindow", 0, "wxSplashScreenWindow *", 0, 0, 0, 0},{"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29635 static swig_type_info _swigt__p_wxPyVScrolledWindow[] = {{"_p_wxPyVScrolledWindow", 0, "wxPyVScrolledWindow *", 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxPyVScrolledWindow, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29636 static swig_type_info _swigt__p_wxPyPopupTransientWindow[] = {{"_p_wxPyPopupTransientWindow", 0, "wxPyPopupTransientWindow *", 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxPyPopupTransientWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29637 static swig_type_info _swigt__p_wxPopupWindow[] = {{"_p_wxPopupWindow", 0, "wxPopupWindow *", 0, 0, 0, 0},{"_p_wxPopupWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxPopupWindow, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxPopupWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29638 static swig_type_info _swigt__p_wxSashWindow[] = {{"_p_wxSashWindow", 0, "wxSashWindow *", 0, 0, 0, 0},{"_p_wxSashWindow", 0, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxSashWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29639 static swig_type_info _swigt__p_wxTopLevelWindow[] = {{"_p_wxTopLevelWindow", 0, "wxTopLevelWindow *", 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", 0, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29640 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxSplashScreen", _p_wxSplashScreenTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMiniFrame", _p_wxMiniFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxProgressDialog", _p_wxProgressDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPanel", _p_wxPanelTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxStatusBar", _p_wxStatusBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTopLevelWindow", _p_wxTopLevelWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSplashScreenWindow", _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSplitterWindow", _p_wxSplitterWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSashLayoutWindow", _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxSashWindow", _p_wxSashWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIClientWindow", _p_wxMDIClientWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPopupWindow", _p_wxPopupWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxTipWindow", _p_wxTipWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPreviewFrame", _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewFrame", _p_wxPreviewFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIChildFrame", _p_wxMDIChildFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyWindow", _p_wxPyWindowTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFrame", _p_wxFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxDialog", _p_wxDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMDIParentFrame", _p_wxMDIParentFrameTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29641 static swig_type_info _swigt__p_wxScrolledWindow[] = {{"_p_wxScrolledWindow", 0, "wxScrolledWindow *", 0, 0, 0, 0},{"_p_wxScrolledWindow", 0, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxScrolledWindow, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxScrolledWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29642 static swig_type_info _swigt__p_wxMenuBar[] = {{"_p_wxMenuBar", 0, "wxMenuBar *", 0, 0, 0, 0},{"_p_wxMenuBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29643 static swig_type_info _swigt__p_wxMDIClientWindow[] = {{"_p_wxMDIClientWindow", 0, "wxMDIClientWindow *", 0, 0, 0, 0},{"_p_wxMDIClientWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29644 static swig_type_info _swigt__p_wxPyScrolledWindow[] = {{"_p_wxPyScrolledWindow", 0, "wxPyScrolledWindow *", 0, 0, 0, 0},{"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29645 static swig_type_info _swigt__p_wxPrintPreview[] = {{"_p_wxPrintPreview", 0, "wxPrintPreview *", 0, 0, 0, 0},{"_p_wxPrintPreview", 0, 0, 0, 0, 0, 0},{"_p_wxPyPrintPreview", _p_wxPyPrintPreviewTo_p_wxPrintPreview, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29646 static swig_type_info _swigt__p_wxSashEvent[] = {{"_p_wxSashEvent", 0, "wxSashEvent *", 0, 0, 0, 0},{"_p_wxSashEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29647 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}};
29648 static swig_type_info _swigt__p_wxPyPrintPreview[] = {{"_p_wxPyPrintPreview", 0, "wxPyPrintPreview *", 0, 0, 0, 0},{"_p_wxPyPrintPreview", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29649 static swig_type_info _swigt__p_wxDirDialog[] = {{"_p_wxDirDialog", 0, "wxDirDialog *", 0, 0, 0, 0},{"_p_wxDirDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29650 static swig_type_info _swigt__p_wxColourDialog[] = {{"_p_wxColourDialog", 0, "wxColourDialog *", 0, 0, 0, 0},{"_p_wxColourDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29651 static swig_type_info _swigt__p_wxDialog[] = {{"_p_wxDialog", 0, "wxDialog *", 0, 0, 0, 0},{"_p_wxDialog", 0, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxDirDialog", _p_wxDirDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxFontDialog", _p_wxFontDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxMultiChoiceDialog", _p_wxMultiChoiceDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxSingleChoiceDialog", _p_wxSingleChoiceDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxTextEntryDialog", _p_wxTextEntryDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxPasswordEntryDialog", _p_wxPasswordEntryDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxMessageDialog", _p_wxMessageDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{"_p_wxFindReplaceDialog", _p_wxFindReplaceDialogTo_p_wxDialog, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29652 static swig_type_info _swigt__p_wxPanel[] = {{"_p_wxPanel", 0, "wxPanel *", 0, 0, 0, 0},{"_p_wxPanel", 0, 0, 0, 0, 0, 0},{"_p_wxScrolledWindow", _p_wxScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyScrolledWindow", _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyVScrolledWindow", _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyVListBox", _p_wxPyVListBoxTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyHtmlListBox", _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyPanel", _p_wxPyPanelTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPreviewCanvas", _p_wxPreviewCanvasTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPreviewControlBar", _p_wxPreviewControlBarTo_p_wxPanel, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29653 static swig_type_info _swigt__p_wxFontDialog[] = {{"_p_wxFontDialog", 0, "wxFontDialog *", 0, 0, 0, 0},{"_p_wxFontDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29654 static swig_type_info _swigt__p_wxPageSetupDialog[] = {{"_p_wxPageSetupDialog", 0, "wxPageSetupDialog *", 0, 0, 0, 0},{"_p_wxPageSetupDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29655 static swig_type_info _swigt__p_wxPrintDialog[] = {{"_p_wxPrintDialog", 0, "wxPrintDialog *", 0, 0, 0, 0},{"_p_wxPrintDialog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29656 static swig_type_info _swigt__p_wxFileSystem[] = {{"_p_wxFileSystem", 0, "wxFileSystem *", 0, 0, 0, 0},{"_p_wxFileSystem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29657 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}};
29658 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}};
29659 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}};
29660 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}};
29661 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29662 static swig_type_info _swigt__p_wxPreviewControlBar[] = {{"_p_wxPreviewControlBar", 0, "wxPreviewControlBar *", 0, 0, 0, 0},{"_p_wxPreviewControlBar", 0, 0, 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxPreviewControlBar, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29663 static swig_type_info _swigt__p_wxPyPreviewControlBar[] = {{"_p_wxPyPreviewControlBar", 0, "wxPyPreviewControlBar *", 0, 0, 0, 0},{"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29664 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}};
29665 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}};
29666 static swig_type_info _swigt__p_wxPageSetupDialogData[] = {{"_p_wxPageSetupDialogData", 0, "wxPageSetupDialogData *", 0, 0, 0, 0},{"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29667 static swig_type_info _swigt__p_wxPrintDialogData[] = {{"_p_wxPrintDialogData", 0, "wxPrintDialogData *", 0, 0, 0, 0},{"_p_wxPrintDialogData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29668
29669 static swig_type_info *swig_types_initial[] = {
29670 _swigt__p_wxQueryLayoutInfoEvent,
29671 _swigt__p_wxPreviewFrame,
29672 _swigt__p_wxPyPreviewFrame,
29673 _swigt__p_wxPyPanel,
29674 _swigt__p_wxMenu,
29675 _swigt__p_wxFontData,
29676 _swigt__p_wxEvent,
29677 _swigt__p_wxPrintData,
29678 _swigt__p_wxTaskBarIcon,
29679 _swigt__p_wxPyTaskBarIcon,
29680 _swigt__p_wxIconBundle,
29681 _swigt__p_wxLayoutAlgorithm,
29682 _swigt__p_wxFindDialogEvent,
29683 _swigt__p_wxPreviewCanvas,
29684 _swigt__p_wxFont,
29685 _swigt__p_wxSplitterEvent,
29686 _swigt__p_wxRegion,
29687 _swigt__ptrdiff_t,
29688 _swigt__std__ptrdiff_t,
29689 _swigt__p_wxFindReplaceData,
29690 _swigt__p_int,
29691 _swigt__p_wxSize,
29692 _swigt__p_wxDC,
29693 _swigt__p_wxIcon,
29694 _swigt__p_wxVisualAttributes,
29695 _swigt__p_wxMDIChildFrame,
29696 _swigt__p_wxColourData,
29697 _swigt__p_wxNotifyEvent,
29698 _swigt__p_wxPyWindow,
29699 _swigt__p_form_ops_t,
29700 _swigt__p_wxSplashScreen,
29701 _swigt__p_wxPasswordEntryDialog,
29702 _swigt__p_wxSingleChoiceDialog,
29703 _swigt__p_wxMultiChoiceDialog,
29704 _swigt__p_wxFileDialog,
29705 _swigt__p_wxTextEntryDialog,
29706 _swigt__p_wxMessageDialog,
29707 _swigt__p_wxProgressDialog,
29708 _swigt__p_wxFindReplaceDialog,
29709 _swigt__p_wxPrinter,
29710 _swigt__p_wxArrayInt,
29711 _swigt__p_wxDuplexMode,
29712 _swigt__p_wxEvtHandler,
29713 _swigt__p_wxCalculateLayoutEvent,
29714 _swigt__p_wxPyHtmlListBox,
29715 _swigt__p_wxPyVListBox,
29716 _swigt__p_wxRect,
29717 _swigt__p_wxStdDialogButtonSizer,
29718 _swigt__p_char,
29719 _swigt__p_wxMiniFrame,
29720 _swigt__p_wxFrame,
29721 _swigt__p_wxPyPrintout,
29722 _swigt__p_wxTaskBarIconEvent,
29723 _swigt__p_wxScrollWinEvent,
29724 _swigt__p_wxPaperSize,
29725 _swigt__p_wxStatusBar,
29726 _swigt__p_wxMDIParentFrame,
29727 _swigt__p_wxPoint,
29728 _swigt__p_wxObject,
29729 _swigt__p_unsigned_long,
29730 _swigt__p_wxTipWindow,
29731 _swigt__p_wxSashLayoutWindow,
29732 _swigt__p_wxSplitterWindow,
29733 _swigt__p_wxSplashScreenWindow,
29734 _swigt__p_wxPyVScrolledWindow,
29735 _swigt__p_wxPyPopupTransientWindow,
29736 _swigt__p_wxPopupWindow,
29737 _swigt__p_wxSashWindow,
29738 _swigt__p_wxTopLevelWindow,
29739 _swigt__p_wxWindow,
29740 _swigt__p_wxScrolledWindow,
29741 _swigt__p_wxMenuBar,
29742 _swigt__p_wxMDIClientWindow,
29743 _swigt__p_wxPyScrolledWindow,
29744 _swigt__p_wxPrintPreview,
29745 _swigt__p_wxSashEvent,
29746 _swigt__p_wxString,
29747 _swigt__p_wxPyPrintPreview,
29748 _swigt__p_wxDirDialog,
29749 _swigt__p_wxColourDialog,
29750 _swigt__p_wxDialog,
29751 _swigt__p_wxPanel,
29752 _swigt__p_wxFontDialog,
29753 _swigt__p_wxPageSetupDialog,
29754 _swigt__p_wxPrintDialog,
29755 _swigt__p_wxFileSystem,
29756 _swigt__p_wxBitmap,
29757 _swigt__unsigned_int,
29758 _swigt__p_unsigned_int,
29759 _swigt__p_unsigned_char,
29760 _swigt__p_wxCommandEvent,
29761 _swigt__p_wxPreviewControlBar,
29762 _swigt__p_wxPyPreviewControlBar,
29763 _swigt__p_wxColour,
29764 _swigt__p_wxToolBar,
29765 _swigt__p_wxPageSetupDialogData,
29766 _swigt__p_wxPrintDialogData,
29767 0
29768 };
29769
29770
29771 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29772
29773 static swig_const_info swig_const_table[] = {
29774 {0, 0, 0, 0.0, 0, 0}};
29775
29776 #ifdef __cplusplus
29777 }
29778 #endif
29779
29780
29781 #ifdef __cplusplus
29782 extern "C" {
29783 #endif
29784
29785     /* Python-specific SWIG API */
29786 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
29787 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29788 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
29789
29790     /* -----------------------------------------------------------------------------
29791      * global variable support code.
29792      * ----------------------------------------------------------------------------- */
29793
29794     typedef struct swig_globalvar {
29795         char       *name;                  /* Name of global variable */
29796         PyObject *(*get_attr)();           /* Return the current value */
29797         int       (*set_attr)(PyObject *); /* Set the value */
29798         struct swig_globalvar *next;
29799     } swig_globalvar;
29800
29801     typedef struct swig_varlinkobject {
29802         PyObject_HEAD
29803         swig_globalvar *vars;
29804     } swig_varlinkobject;
29805
29806     static PyObject *
29807     swig_varlink_repr(swig_varlinkobject *v) {
29808         v = v;
29809         return PyString_FromString("<Swig global variables>");
29810     }
29811
29812     static int
29813     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
29814         swig_globalvar  *var;
29815         flags = flags;
29816         fprintf(fp,"Swig global variables { ");
29817         for (var = v->vars; var; var=var->next) {
29818             fprintf(fp,"%s", var->name);
29819             if (var->next) fprintf(fp,", ");
29820         }
29821         fprintf(fp," }\n");
29822         return 0;
29823     }
29824
29825     static PyObject *
29826     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29827         swig_globalvar *var = v->vars;
29828         while (var) {
29829             if (strcmp(var->name,n) == 0) {
29830                 return (*var->get_attr)();
29831             }
29832             var = var->next;
29833         }
29834         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29835         return NULL;
29836     }
29837
29838     static int
29839     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29840         swig_globalvar *var = v->vars;
29841         while (var) {
29842             if (strcmp(var->name,n) == 0) {
29843                 return (*var->set_attr)(p);
29844             }
29845             var = var->next;
29846         }
29847         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29848         return 1;
29849     }
29850
29851     static PyTypeObject varlinktype = {
29852         PyObject_HEAD_INIT(0)
29853         0,                                  /* Number of items in variable part (ob_size) */
29854         (char *)"swigvarlink",              /* Type name (tp_name) */
29855         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
29856         0,                                  /* Itemsize (tp_itemsize) */
29857         0,                                  /* Deallocator (tp_dealloc) */
29858         (printfunc) swig_varlink_print,     /* Print (tp_print) */
29859         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29860         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
29861         0,                                  /* tp_compare */
29862         (reprfunc) swig_varlink_repr,       /* tp_repr */
29863         0,                                  /* tp_as_number */
29864         0,                                  /* tp_as_sequence */
29865         0,                                  /* tp_as_mapping */
29866         0,                                  /* tp_hash */
29867         0,                                  /* tp_call */
29868         0,                                  /* tp_str */
29869         0,                                  /* tp_getattro */
29870         0,                                  /* tp_setattro */
29871         0,                                  /* tp_as_buffer */
29872         0,                                  /* tp_flags */
29873         0,                                  /* tp_doc */
29874 #if PY_VERSION_HEX >= 0x02000000
29875         0,                                  /* tp_traverse */
29876         0,                                  /* tp_clear */
29877 #endif
29878 #if PY_VERSION_HEX >= 0x02010000
29879         0,                                  /* tp_richcompare */
29880         0,                                  /* tp_weaklistoffset */
29881 #endif
29882 #if PY_VERSION_HEX >= 0x02020000
29883         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
29884 #endif
29885 #if PY_VERSION_HEX >= 0x02030000
29886         0,                                  /* tp_del */
29887 #endif
29888 #ifdef COUNT_ALLOCS
29889         0,0,0,0                             /* tp_alloc -> tp_next */
29890 #endif
29891     };
29892
29893     /* Create a variable linking object for use later */
29894     static PyObject *
29895     SWIG_Python_newvarlink(void) {
29896         swig_varlinkobject *result = 0;
29897         result = PyMem_NEW(swig_varlinkobject,1);
29898         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
29899         result->ob_type = &varlinktype;
29900         result->vars = 0;
29901         result->ob_refcnt = 0;
29902         Py_XINCREF((PyObject *) result);
29903         return ((PyObject*) result);
29904     }
29905
29906     static void
29907     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
29908         swig_varlinkobject *v;
29909         swig_globalvar *gv;
29910         v= (swig_varlinkobject *) p;
29911         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
29912         gv->name = (char *) malloc(strlen(name)+1);
29913         strcpy(gv->name,name);
29914         gv->get_attr = get_attr;
29915         gv->set_attr = set_attr;
29916         gv->next = v->vars;
29917         v->vars = gv;
29918     }
29919
29920     /* -----------------------------------------------------------------------------
29921      * constants/methods manipulation
29922      * ----------------------------------------------------------------------------- */
29923
29924     /* Install Constants */
29925     static void
29926     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
29927         PyObject *obj = 0;
29928         size_t i;
29929         for (i = 0; constants[i].type; i++) {
29930             switch(constants[i].type) {
29931                 case SWIG_PY_INT:
29932                 obj = PyInt_FromLong(constants[i].lvalue);
29933                 break;
29934                 case SWIG_PY_FLOAT:
29935                 obj = PyFloat_FromDouble(constants[i].dvalue);
29936                 break;
29937                 case SWIG_PY_STRING:
29938                 if (constants[i].pvalue) {
29939                     obj = PyString_FromString((char *) constants[i].pvalue);
29940                 } else {
29941                     Py_INCREF(Py_None);
29942                     obj = Py_None;
29943                 }
29944                 break;
29945                 case SWIG_PY_POINTER:
29946                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
29947                 break;
29948                 case SWIG_PY_BINARY:
29949                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
29950                 break;
29951                 default:
29952                 obj = 0;
29953                 break;
29954             }
29955             if (obj) {
29956                 PyDict_SetItemString(d,constants[i].name,obj);
29957                 Py_DECREF(obj);
29958             }
29959         }
29960     }
29961
29962     /* -----------------------------------------------------------------------------*/
29963     /* Fix SwigMethods to carry the callback ptrs when needed */
29964     /* -----------------------------------------------------------------------------*/
29965
29966     static void
29967     SWIG_Python_FixMethods(PyMethodDef *methods,
29968     swig_const_info *const_table,
29969     swig_type_info **types,
29970     swig_type_info **types_initial) {
29971         size_t i;
29972         for (i = 0; methods[i].ml_name; ++i) {
29973             char *c = methods[i].ml_doc;
29974             if (c && (c = strstr(c, "swig_ptr: "))) {
29975                 int j;
29976                 swig_const_info *ci = 0;
29977                 char *name = c + 10;
29978                 for (j = 0; const_table[j].type; j++) {
29979                     if (strncmp(const_table[j].name, name,
29980                     strlen(const_table[j].name)) == 0) {
29981                         ci = &(const_table[j]);
29982                         break;
29983                     }
29984                 }
29985                 if (ci) {
29986                     size_t shift = (ci->ptype) - types;
29987                     swig_type_info *ty = types_initial[shift];
29988                     size_t ldoc = (c - methods[i].ml_doc);
29989                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
29990                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
29991                     char *buff = ndoc;
29992                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
29993                     strncpy(buff, methods[i].ml_doc, ldoc);
29994                     buff += ldoc;
29995                     strncpy(buff, "swig_ptr: ", 10);
29996                     buff += 10;
29997                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
29998                     methods[i].ml_doc = ndoc;
29999                 }
30000             }
30001         }
30002     }
30003
30004     /* -----------------------------------------------------------------------------*
30005      *  Initialize type list
30006      * -----------------------------------------------------------------------------*/
30007
30008 #if PY_MAJOR_VERSION < 2
30009     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
30010     is copied out of Python/modsupport.c in python version 2.3.4 */
30011     static int
30012     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
30013     {
30014         PyObject *dict;
30015         if (!PyModule_Check(m)) {
30016             PyErr_SetString(PyExc_TypeError,
30017             "PyModule_AddObject() needs module as first arg");
30018             return -1;
30019         }
30020         if (!o) {
30021             PyErr_SetString(PyExc_TypeError,
30022             "PyModule_AddObject() needs non-NULL value");
30023             return -1;
30024         }
30025
30026         dict = PyModule_GetDict(m);
30027         if (dict == NULL) {
30028             /* Internal error -- modules must have a dict! */
30029             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
30030             PyModule_GetName(m));
30031             return -1;
30032         }
30033         if (PyDict_SetItemString(dict, name, o))
30034         return -1;
30035         Py_DECREF(o);
30036         return 0;
30037     }
30038 #endif
30039
30040     static swig_type_info **
30041     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
30042         static PyMethodDef swig_empty_runtime_method_table[] = {
30043             {
30044                 NULL, NULL, 0, NULL
30045             }
30046         };/* Sentinel */
30047
30048         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
30049         swig_empty_runtime_method_table);
30050         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
30051         if (pointer && module) {
30052             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
30053         }
30054         return type_list_handle;
30055     }
30056
30057     static swig_type_info **
30058     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
30059         swig_type_info **type_pointer;
30060
30061         /* first check if module already created */
30062         type_pointer = SWIG_Python_GetTypeListHandle();
30063         if (type_pointer) {
30064             return type_pointer;
30065         } else {
30066             /* create a new module and variable */
30067             return SWIG_Python_SetTypeListHandle(type_list_handle);
30068         }
30069     }
30070
30071 #ifdef __cplusplus
30072 }
30073 #endif
30074
30075 /* -----------------------------------------------------------------------------*
30076  *  Partial Init method
30077  * -----------------------------------------------------------------------------*/
30078
30079 #ifdef SWIG_LINK_RUNTIME
30080 #ifdef __cplusplus
30081 extern "C"
30082 #endif
30083 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
30084 #endif
30085
30086 #ifdef __cplusplus
30087 extern "C"
30088 #endif
30089 SWIGEXPORT(void) SWIG_init(void) {
30090     static PyObject *SWIG_globals = 0;
30091     static int       typeinit = 0;
30092     PyObject *m, *d;
30093     int       i;
30094     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
30095
30096     /* Fix SwigMethods to carry the callback ptrs when needed */
30097     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
30098
30099     m = Py_InitModule((char *) SWIG_name, SwigMethods);
30100     d = PyModule_GetDict(m);
30101
30102     if (!typeinit) {
30103 #ifdef SWIG_LINK_RUNTIME
30104         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
30105 #else
30106 #  ifndef SWIG_STATIC_RUNTIME
30107         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
30108 #  endif
30109 #endif
30110         for (i = 0; swig_types_initial[i]; i++) {
30111             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
30112         }
30113         typeinit = 1;
30114     }
30115     SWIG_InstallConstants(d,swig_const_table);
30116
30117     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
30118     SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
30119     SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
30120     SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
30121     SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
30122     {
30123         PyDict_SetItemString(d,"STAY_ON_TOP", SWIG_From_int((int)(wxSTAY_ON_TOP)));
30124     }
30125     {
30126         PyDict_SetItemString(d,"ICONIZE", SWIG_From_int((int)(wxICONIZE)));
30127     }
30128     {
30129         PyDict_SetItemString(d,"MINIMIZE", SWIG_From_int((int)(wxMINIMIZE)));
30130     }
30131     {
30132         PyDict_SetItemString(d,"MAXIMIZE", SWIG_From_int((int)(wxMAXIMIZE)));
30133     }
30134     {
30135         PyDict_SetItemString(d,"CLOSE_BOX", SWIG_From_int((int)(wxCLOSE_BOX)));
30136     }
30137     {
30138         PyDict_SetItemString(d,"THICK_FRAME", SWIG_From_int((int)(wxTHICK_FRAME)));
30139     }
30140     {
30141         PyDict_SetItemString(d,"SYSTEM_MENU", SWIG_From_int((int)(wxSYSTEM_MENU)));
30142     }
30143     {
30144         PyDict_SetItemString(d,"MINIMIZE_BOX", SWIG_From_int((int)(wxMINIMIZE_BOX)));
30145     }
30146     {
30147         PyDict_SetItemString(d,"MAXIMIZE_BOX", SWIG_From_int((int)(wxMAXIMIZE_BOX)));
30148     }
30149     {
30150         PyDict_SetItemString(d,"TINY_CAPTION_HORIZ", SWIG_From_int((int)(wxTINY_CAPTION_HORIZ)));
30151     }
30152     {
30153         PyDict_SetItemString(d,"TINY_CAPTION_VERT", SWIG_From_int((int)(wxTINY_CAPTION_VERT)));
30154     }
30155     {
30156         PyDict_SetItemString(d,"RESIZE_BOX", SWIG_From_int((int)(wxRESIZE_BOX)));
30157     }
30158     {
30159         PyDict_SetItemString(d,"RESIZE_BORDER", SWIG_From_int((int)(wxRESIZE_BORDER)));
30160     }
30161     {
30162         PyDict_SetItemString(d,"DIALOG_NO_PARENT", SWIG_From_int((int)(wxDIALOG_NO_PARENT)));
30163     }
30164     {
30165         PyDict_SetItemString(d,"DEFAULT_FRAME_STYLE", SWIG_From_int((int)(wxDEFAULT_FRAME_STYLE)));
30166     }
30167     {
30168         PyDict_SetItemString(d,"DEFAULT_DIALOG_STYLE", SWIG_From_int((int)(wxDEFAULT_DIALOG_STYLE)));
30169     }
30170     {
30171         PyDict_SetItemString(d,"FRAME_TOOL_WINDOW", SWIG_From_int((int)(wxFRAME_TOOL_WINDOW)));
30172     }
30173     {
30174         PyDict_SetItemString(d,"FRAME_FLOAT_ON_PARENT", SWIG_From_int((int)(wxFRAME_FLOAT_ON_PARENT)));
30175     }
30176     {
30177         PyDict_SetItemString(d,"FRAME_NO_WINDOW_MENU", SWIG_From_int((int)(wxFRAME_NO_WINDOW_MENU)));
30178     }
30179     {
30180         PyDict_SetItemString(d,"FRAME_NO_TASKBAR", SWIG_From_int((int)(wxFRAME_NO_TASKBAR)));
30181     }
30182     {
30183         PyDict_SetItemString(d,"FRAME_SHAPED", SWIG_From_int((int)(wxFRAME_SHAPED)));
30184     }
30185     {
30186         PyDict_SetItemString(d,"FRAME_DRAWER", SWIG_From_int((int)(wxFRAME_DRAWER)));
30187     }
30188     {
30189         PyDict_SetItemString(d,"FRAME_EX_METAL", SWIG_From_int((int)(wxFRAME_EX_METAL)));
30190     }
30191     {
30192         PyDict_SetItemString(d,"DIALOG_EX_METAL", SWIG_From_int((int)(wxDIALOG_EX_METAL)));
30193     }
30194     {
30195         PyDict_SetItemString(d,"DIALOG_MODAL", SWIG_From_int((int)(wxDIALOG_MODAL)));
30196     }
30197     {
30198         PyDict_SetItemString(d,"DIALOG_MODELESS", SWIG_From_int((int)(wxDIALOG_MODELESS)));
30199     }
30200     {
30201         PyDict_SetItemString(d,"USER_COLOURS", SWIG_From_int((int)(wxUSER_COLOURS)));
30202     }
30203     {
30204         PyDict_SetItemString(d,"NO_3D", SWIG_From_int((int)(wxNO_3D)));
30205     }
30206     {
30207         PyDict_SetItemString(d,"FULLSCREEN_NOMENUBAR", SWIG_From_int((int)(wxFULLSCREEN_NOMENUBAR)));
30208     }
30209     {
30210         PyDict_SetItemString(d,"FULLSCREEN_NOTOOLBAR", SWIG_From_int((int)(wxFULLSCREEN_NOTOOLBAR)));
30211     }
30212     {
30213         PyDict_SetItemString(d,"FULLSCREEN_NOSTATUSBAR", SWIG_From_int((int)(wxFULLSCREEN_NOSTATUSBAR)));
30214     }
30215     {
30216         PyDict_SetItemString(d,"FULLSCREEN_NOBORDER", SWIG_From_int((int)(wxFULLSCREEN_NOBORDER)));
30217     }
30218     {
30219         PyDict_SetItemString(d,"FULLSCREEN_NOCAPTION", SWIG_From_int((int)(wxFULLSCREEN_NOCAPTION)));
30220     }
30221     {
30222         PyDict_SetItemString(d,"FULLSCREEN_ALL", SWIG_From_int((int)(wxFULLSCREEN_ALL)));
30223     }
30224     {
30225         PyDict_SetItemString(d,"TOPLEVEL_EX_DIALOG", SWIG_From_int((int)(wxTOPLEVEL_EX_DIALOG)));
30226     }
30227     {
30228         PyDict_SetItemString(d,"USER_ATTENTION_INFO", SWIG_From_int((int)(wxUSER_ATTENTION_INFO)));
30229     }
30230     {
30231         PyDict_SetItemString(d,"USER_ATTENTION_ERROR", SWIG_From_int((int)(wxUSER_ATTENTION_ERROR)));
30232     }
30233     {
30234         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_PARENT", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_PARENT)));
30235     }
30236     {
30237         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_SCREEN", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_SCREEN)));
30238     }
30239     {
30240         PyDict_SetItemString(d,"SPLASH_NO_CENTRE", SWIG_From_int((int)(wxSPLASH_NO_CENTRE)));
30241     }
30242     {
30243         PyDict_SetItemString(d,"SPLASH_TIMEOUT", SWIG_From_int((int)(wxSPLASH_TIMEOUT)));
30244     }
30245     {
30246         PyDict_SetItemString(d,"SPLASH_NO_TIMEOUT", SWIG_From_int((int)(wxSPLASH_NO_TIMEOUT)));
30247     }
30248     {
30249         PyDict_SetItemString(d,"SB_NORMAL", SWIG_From_int((int)(wxSB_NORMAL)));
30250     }
30251     {
30252         PyDict_SetItemString(d,"SB_FLAT", SWIG_From_int((int)(wxSB_FLAT)));
30253     }
30254     {
30255         PyDict_SetItemString(d,"SB_RAISED", SWIG_From_int((int)(wxSB_RAISED)));
30256     }
30257     SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
30258     {
30259         PyDict_SetItemString(d,"SP_NOBORDER", SWIG_From_int((int)(wxSP_NOBORDER)));
30260     }
30261     {
30262         PyDict_SetItemString(d,"SP_NOSASH", SWIG_From_int((int)(wxSP_NOSASH)));
30263     }
30264     {
30265         PyDict_SetItemString(d,"SP_PERMIT_UNSPLIT", SWIG_From_int((int)(wxSP_PERMIT_UNSPLIT)));
30266     }
30267     {
30268         PyDict_SetItemString(d,"SP_LIVE_UPDATE", SWIG_From_int((int)(wxSP_LIVE_UPDATE)));
30269     }
30270     {
30271         PyDict_SetItemString(d,"SP_3DSASH", SWIG_From_int((int)(wxSP_3DSASH)));
30272     }
30273     {
30274         PyDict_SetItemString(d,"SP_3DBORDER", SWIG_From_int((int)(wxSP_3DBORDER)));
30275     }
30276     {
30277         PyDict_SetItemString(d,"SP_NO_XP_THEME", SWIG_From_int((int)(wxSP_NO_XP_THEME)));
30278     }
30279     {
30280         PyDict_SetItemString(d,"SP_BORDER", SWIG_From_int((int)(wxSP_BORDER)));
30281     }
30282     {
30283         PyDict_SetItemString(d,"SP_3D", SWIG_From_int((int)(wxSP_3D)));
30284     }
30285     {
30286         PyDict_SetItemString(d,"SPLIT_HORIZONTAL", SWIG_From_int((int)(wxSPLIT_HORIZONTAL)));
30287     }
30288     {
30289         PyDict_SetItemString(d,"SPLIT_VERTICAL", SWIG_From_int((int)(wxSPLIT_VERTICAL)));
30290     }
30291     {
30292         PyDict_SetItemString(d,"SPLIT_DRAG_NONE", SWIG_From_int((int)(wxSPLIT_DRAG_NONE)));
30293     }
30294     {
30295         PyDict_SetItemString(d,"SPLIT_DRAG_DRAGGING", SWIG_From_int((int)(wxSPLIT_DRAG_DRAGGING)));
30296     }
30297     {
30298         PyDict_SetItemString(d,"SPLIT_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSPLIT_DRAG_LEFT_DOWN)));
30299     }
30300     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
30301     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
30302     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
30303     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
30304     SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
30305     SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
30306     {
30307         PyDict_SetItemString(d,"SASH_DRAG_NONE", SWIG_From_int((int)(wxSASH_DRAG_NONE)));
30308     }
30309     {
30310         PyDict_SetItemString(d,"SASH_DRAG_DRAGGING", SWIG_From_int((int)(wxSASH_DRAG_DRAGGING)));
30311     }
30312     {
30313         PyDict_SetItemString(d,"SASH_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSASH_DRAG_LEFT_DOWN)));
30314     }
30315     {
30316         PyDict_SetItemString(d,"SW_NOBORDER", SWIG_From_int((int)(wxSW_NOBORDER)));
30317     }
30318     {
30319         PyDict_SetItemString(d,"SW_BORDER", SWIG_From_int((int)(wxSW_BORDER)));
30320     }
30321     {
30322         PyDict_SetItemString(d,"SW_3DSASH", SWIG_From_int((int)(wxSW_3DSASH)));
30323     }
30324     {
30325         PyDict_SetItemString(d,"SW_3DBORDER", SWIG_From_int((int)(wxSW_3DBORDER)));
30326     }
30327     {
30328         PyDict_SetItemString(d,"SW_3D", SWIG_From_int((int)(wxSW_3D)));
30329     }
30330     {
30331         PyDict_SetItemString(d,"SASH_TOP", SWIG_From_int((int)(wxSASH_TOP)));
30332     }
30333     {
30334         PyDict_SetItemString(d,"SASH_RIGHT", SWIG_From_int((int)(wxSASH_RIGHT)));
30335     }
30336     {
30337         PyDict_SetItemString(d,"SASH_BOTTOM", SWIG_From_int((int)(wxSASH_BOTTOM)));
30338     }
30339     {
30340         PyDict_SetItemString(d,"SASH_LEFT", SWIG_From_int((int)(wxSASH_LEFT)));
30341     }
30342     {
30343         PyDict_SetItemString(d,"SASH_NONE", SWIG_From_int((int)(wxSASH_NONE)));
30344     }
30345     {
30346         PyDict_SetItemString(d,"SASH_STATUS_OK", SWIG_From_int((int)(wxSASH_STATUS_OK)));
30347     }
30348     {
30349         PyDict_SetItemString(d,"SASH_STATUS_OUT_OF_RANGE", SWIG_From_int((int)(wxSASH_STATUS_OUT_OF_RANGE)));
30350     }
30351     PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
30352     {
30353         PyDict_SetItemString(d,"LAYOUT_HORIZONTAL", SWIG_From_int((int)(wxLAYOUT_HORIZONTAL)));
30354     }
30355     {
30356         PyDict_SetItemString(d,"LAYOUT_VERTICAL", SWIG_From_int((int)(wxLAYOUT_VERTICAL)));
30357     }
30358     {
30359         PyDict_SetItemString(d,"LAYOUT_NONE", SWIG_From_int((int)(wxLAYOUT_NONE)));
30360     }
30361     {
30362         PyDict_SetItemString(d,"LAYOUT_TOP", SWIG_From_int((int)(wxLAYOUT_TOP)));
30363     }
30364     {
30365         PyDict_SetItemString(d,"LAYOUT_LEFT", SWIG_From_int((int)(wxLAYOUT_LEFT)));
30366     }
30367     {
30368         PyDict_SetItemString(d,"LAYOUT_RIGHT", SWIG_From_int((int)(wxLAYOUT_RIGHT)));
30369     }
30370     {
30371         PyDict_SetItemString(d,"LAYOUT_BOTTOM", SWIG_From_int((int)(wxLAYOUT_BOTTOM)));
30372     }
30373     {
30374         PyDict_SetItemString(d,"LAYOUT_LENGTH_Y", SWIG_From_int((int)(wxLAYOUT_LENGTH_Y)));
30375     }
30376     {
30377         PyDict_SetItemString(d,"LAYOUT_LENGTH_X", SWIG_From_int((int)(wxLAYOUT_LENGTH_X)));
30378     }
30379     {
30380         PyDict_SetItemString(d,"LAYOUT_MRU_LENGTH", SWIG_From_int((int)(wxLAYOUT_MRU_LENGTH)));
30381     }
30382     {
30383         PyDict_SetItemString(d,"LAYOUT_QUERY", SWIG_From_int((int)(wxLAYOUT_QUERY)));
30384     }
30385     PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
30386     PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
30387     SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
30388
30389     // Map renamed classes back to their common name for OOR
30390     wxPyPtrTypeMap_Add("wxHtmlListBox",     "wxPyHtmlListBox");
30391     wxPyPtrTypeMap_Add("wxVListBox",        "wxPyVListBox");
30392     wxPyPtrTypeMap_Add("wxVScrolledWindow", "wxPyVScrolledWindow");
30393
30394     PyDict_SetItemString(d, "wxEVT_TASKBAR_MOVE", PyInt_FromLong(wxEVT_TASKBAR_MOVE));
30395     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DOWN));
30396     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_UP", PyInt_FromLong(wxEVT_TASKBAR_LEFT_UP));
30397     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DOWN));
30398     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
30399     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
30400     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
30401     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
30402     SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
30403     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
30404     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
30405     SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
30406     SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
30407     {
30408         PyDict_SetItemString(d,"CHOICEDLG_STYLE", SWIG_From_int((int)(wxCHOICEDLG_STYLE)));
30409     }
30410     {
30411         PyDict_SetItemString(d,"TextEntryDialogStyle", SWIG_From_int((int)(wxTextEntryDialogStyle)));
30412     }
30413     SWIG_addvarlink(SWIG_globals,(char*)"GetPasswordFromUserPromptStr",_wrap_GetPasswordFromUserPromptStr_get, _wrap_GetPasswordFromUserPromptStr_set);
30414     {
30415         PyDict_SetItemString(d,"FR_DOWN", SWIG_From_int((int)(wxFR_DOWN)));
30416     }
30417     {
30418         PyDict_SetItemString(d,"FR_WHOLEWORD", SWIG_From_int((int)(wxFR_WHOLEWORD)));
30419     }
30420     {
30421         PyDict_SetItemString(d,"FR_MATCHCASE", SWIG_From_int((int)(wxFR_MATCHCASE)));
30422     }
30423     {
30424         PyDict_SetItemString(d,"FR_REPLACEDIALOG", SWIG_From_int((int)(wxFR_REPLACEDIALOG)));
30425     }
30426     {
30427         PyDict_SetItemString(d,"FR_NOUPDOWN", SWIG_From_int((int)(wxFR_NOUPDOWN)));
30428     }
30429     {
30430         PyDict_SetItemString(d,"FR_NOMATCHCASE", SWIG_From_int((int)(wxFR_NOMATCHCASE)));
30431     }
30432     {
30433         PyDict_SetItemString(d,"FR_NOWHOLEWORD", SWIG_From_int((int)(wxFR_NOWHOLEWORD)));
30434     }
30435     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
30436     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
30437     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
30438     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
30439     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
30440     {
30441         PyDict_SetItemString(d,"IDM_WINDOWTILE", SWIG_From_int((int)(4001)));
30442     }
30443     {
30444         PyDict_SetItemString(d,"IDM_WINDOWTILEHOR", SWIG_From_int((int)(4001)));
30445     }
30446     {
30447         PyDict_SetItemString(d,"IDM_WINDOWCASCADE", SWIG_From_int((int)(4002)));
30448     }
30449     {
30450         PyDict_SetItemString(d,"IDM_WINDOWICONS", SWIG_From_int((int)(4003)));
30451     }
30452     {
30453         PyDict_SetItemString(d,"IDM_WINDOWNEXT", SWIG_From_int((int)(4004)));
30454     }
30455     {
30456         PyDict_SetItemString(d,"IDM_WINDOWTILEVERT", SWIG_From_int((int)(4005)));
30457     }
30458     {
30459         PyDict_SetItemString(d,"IDM_WINDOWPREV", SWIG_From_int((int)(4006)));
30460     }
30461     {
30462         PyDict_SetItemString(d,"FIRST_MDI_CHILD", SWIG_From_int((int)(4100)));
30463     }
30464     {
30465         PyDict_SetItemString(d,"LAST_MDI_CHILD", SWIG_From_int((int)(4600)));
30466     }
30467     SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
30468     SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
30469     {
30470         PyDict_SetItemString(d,"PRINT_MODE_NONE", SWIG_From_int((int)(wxPRINT_MODE_NONE)));
30471     }
30472     {
30473         PyDict_SetItemString(d,"PRINT_MODE_PREVIEW", SWIG_From_int((int)(wxPRINT_MODE_PREVIEW)));
30474     }
30475     {
30476         PyDict_SetItemString(d,"PRINT_MODE_FILE", SWIG_From_int((int)(wxPRINT_MODE_FILE)));
30477     }
30478     {
30479         PyDict_SetItemString(d,"PRINT_MODE_PRINTER", SWIG_From_int((int)(wxPRINT_MODE_PRINTER)));
30480     }
30481     {
30482         PyDict_SetItemString(d,"PRINT_MODE_STREAM", SWIG_From_int((int)(wxPRINT_MODE_STREAM)));
30483     }
30484     {
30485         PyDict_SetItemString(d,"PRINTBIN_DEFAULT", SWIG_From_int((int)(wxPRINTBIN_DEFAULT)));
30486     }
30487     {
30488         PyDict_SetItemString(d,"PRINTBIN_ONLYONE", SWIG_From_int((int)(wxPRINTBIN_ONLYONE)));
30489     }
30490     {
30491         PyDict_SetItemString(d,"PRINTBIN_LOWER", SWIG_From_int((int)(wxPRINTBIN_LOWER)));
30492     }
30493     {
30494         PyDict_SetItemString(d,"PRINTBIN_MIDDLE", SWIG_From_int((int)(wxPRINTBIN_MIDDLE)));
30495     }
30496     {
30497         PyDict_SetItemString(d,"PRINTBIN_MANUAL", SWIG_From_int((int)(wxPRINTBIN_MANUAL)));
30498     }
30499     {
30500         PyDict_SetItemString(d,"PRINTBIN_ENVELOPE", SWIG_From_int((int)(wxPRINTBIN_ENVELOPE)));
30501     }
30502     {
30503         PyDict_SetItemString(d,"PRINTBIN_ENVMANUAL", SWIG_From_int((int)(wxPRINTBIN_ENVMANUAL)));
30504     }
30505     {
30506         PyDict_SetItemString(d,"PRINTBIN_AUTO", SWIG_From_int((int)(wxPRINTBIN_AUTO)));
30507     }
30508     {
30509         PyDict_SetItemString(d,"PRINTBIN_TRACTOR", SWIG_From_int((int)(wxPRINTBIN_TRACTOR)));
30510     }
30511     {
30512         PyDict_SetItemString(d,"PRINTBIN_SMALLFMT", SWIG_From_int((int)(wxPRINTBIN_SMALLFMT)));
30513     }
30514     {
30515         PyDict_SetItemString(d,"PRINTBIN_LARGEFMT", SWIG_From_int((int)(wxPRINTBIN_LARGEFMT)));
30516     }
30517     {
30518         PyDict_SetItemString(d,"PRINTBIN_LARGECAPACITY", SWIG_From_int((int)(wxPRINTBIN_LARGECAPACITY)));
30519     }
30520     {
30521         PyDict_SetItemString(d,"PRINTBIN_CASSETTE", SWIG_From_int((int)(wxPRINTBIN_CASSETTE)));
30522     }
30523     {
30524         PyDict_SetItemString(d,"PRINTBIN_FORMSOURCE", SWIG_From_int((int)(wxPRINTBIN_FORMSOURCE)));
30525     }
30526     {
30527         PyDict_SetItemString(d,"PRINTBIN_USER", SWIG_From_int((int)(wxPRINTBIN_USER)));
30528     }
30529     {
30530         PyDict_SetItemString(d,"PRINTER_NO_ERROR", SWIG_From_int((int)(wxPRINTER_NO_ERROR)));
30531     }
30532     {
30533         PyDict_SetItemString(d,"PRINTER_CANCELLED", SWIG_From_int((int)(wxPRINTER_CANCELLED)));
30534     }
30535     {
30536         PyDict_SetItemString(d,"PRINTER_ERROR", SWIG_From_int((int)(wxPRINTER_ERROR)));
30537     }
30538     {
30539         PyDict_SetItemString(d,"PREVIEW_PRINT", SWIG_From_int((int)(wxPREVIEW_PRINT)));
30540     }
30541     {
30542         PyDict_SetItemString(d,"PREVIEW_PREVIOUS", SWIG_From_int((int)(wxPREVIEW_PREVIOUS)));
30543     }
30544     {
30545         PyDict_SetItemString(d,"PREVIEW_NEXT", SWIG_From_int((int)(wxPREVIEW_NEXT)));
30546     }
30547     {
30548         PyDict_SetItemString(d,"PREVIEW_ZOOM", SWIG_From_int((int)(wxPREVIEW_ZOOM)));
30549     }
30550     {
30551         PyDict_SetItemString(d,"PREVIEW_FIRST", SWIG_From_int((int)(wxPREVIEW_FIRST)));
30552     }
30553     {
30554         PyDict_SetItemString(d,"PREVIEW_LAST", SWIG_From_int((int)(wxPREVIEW_LAST)));
30555     }
30556     {
30557         PyDict_SetItemString(d,"PREVIEW_GOTO", SWIG_From_int((int)(wxPREVIEW_GOTO)));
30558     }
30559     {
30560         PyDict_SetItemString(d,"PREVIEW_DEFAULT", SWIG_From_int((int)(wxPREVIEW_DEFAULT)));
30561     }
30562     {
30563         PyDict_SetItemString(d,"ID_PREVIEW_CLOSE", SWIG_From_int((int)(wxID_PREVIEW_CLOSE)));
30564     }
30565     {
30566         PyDict_SetItemString(d,"ID_PREVIEW_NEXT", SWIG_From_int((int)(wxID_PREVIEW_NEXT)));
30567     }
30568     {
30569         PyDict_SetItemString(d,"ID_PREVIEW_PREVIOUS", SWIG_From_int((int)(wxID_PREVIEW_PREVIOUS)));
30570     }
30571     {
30572         PyDict_SetItemString(d,"ID_PREVIEW_PRINT", SWIG_From_int((int)(wxID_PREVIEW_PRINT)));
30573     }
30574     {
30575         PyDict_SetItemString(d,"ID_PREVIEW_ZOOM", SWIG_From_int((int)(wxID_PREVIEW_ZOOM)));
30576     }
30577     {
30578         PyDict_SetItemString(d,"ID_PREVIEW_FIRST", SWIG_From_int((int)(wxID_PREVIEW_FIRST)));
30579     }
30580     {
30581         PyDict_SetItemString(d,"ID_PREVIEW_LAST", SWIG_From_int((int)(wxID_PREVIEW_LAST)));
30582     }
30583     {
30584         PyDict_SetItemString(d,"ID_PREVIEW_GOTO", SWIG_From_int((int)(wxID_PREVIEW_GOTO)));
30585     }
30586
30587     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
30588
30589 }
30590