wxPython/src/gtk/_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   /*@/opt/swig/share/swig/1.3.24/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   /*@/opt/swig/share/swig/1.3.24/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   /*@/opt/swig/share/swig/1.3.24/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_DoPrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
3877     PyObject *resultobj;
3878     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3879     wxDC *arg2 = 0 ;
3880     PyObject * obj0 = 0 ;
3881     PyObject * obj1 = 0 ;
3882     char *kwnames[] = {
3883         (char *) "self",(char *) "dc", NULL
3884     };
3885
3886     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_DoPrepareDC",kwnames,&obj0,&obj1)) goto fail;
3887     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3888     if (SWIG_arg_fail(1)) SWIG_fail;
3889     {
3890         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3891         if (SWIG_arg_fail(2)) SWIG_fail;
3892         if (arg2 == NULL) {
3893             SWIG_null_ref("wxDC");
3894         }
3895         if (SWIG_arg_fail(2)) SWIG_fail;
3896     }
3897     {
3898         PyThreadState* __tstate = wxPyBeginAllowThreads();
3899         (arg1)->DoPrepareDC(*arg2);
3900
3901         wxPyEndAllowThreads(__tstate);
3902         if (PyErr_Occurred()) SWIG_fail;
3903     }
3904     Py_INCREF(Py_None); resultobj = Py_None;
3905     return resultobj;
3906     fail:
3907     return NULL;
3908 }
3909
3910
3911 static PyObject *_wrap_ScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3912     PyObject *resultobj;
3913     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3914     wxVisualAttributes result;
3915     PyObject * obj0 = 0 ;
3916     char *kwnames[] = {
3917         (char *) "variant", NULL
3918     };
3919
3920     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrolledWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3921     if (obj0) {
3922         {
3923             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
3924             if (SWIG_arg_fail(1)) SWIG_fail;
3925         }
3926     }
3927     {
3928         if (!wxPyCheckForApp()) SWIG_fail;
3929         PyThreadState* __tstate = wxPyBeginAllowThreads();
3930         result = wxScrolledWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
3931
3932         wxPyEndAllowThreads(__tstate);
3933         if (PyErr_Occurred()) SWIG_fail;
3934     }
3935     {
3936         wxVisualAttributes * resultptr;
3937         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
3938         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
3939     }
3940     return resultobj;
3941     fail:
3942     return NULL;
3943 }
3944
3945
3946 static PyObject * ScrolledWindow_swigregister(PyObject *, PyObject *args) {
3947     PyObject *obj;
3948     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3949     SWIG_TypeClientData(SWIGTYPE_p_wxScrolledWindow, obj);
3950     Py_INCREF(obj);
3951     return Py_BuildValue((char *)"");
3952 }
3953 static int _wrap_FrameNameStr_set(PyObject *) {
3954     PyErr_SetString(PyExc_TypeError,"Variable FrameNameStr is read-only.");
3955     return 1;
3956 }
3957
3958
3959 static PyObject *_wrap_FrameNameStr_get(void) {
3960     PyObject *pyobj;
3961
3962     {
3963 #if wxUSE_UNICODE
3964         pyobj = PyUnicode_FromWideChar((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
3965 #else
3966         pyobj = PyString_FromStringAndSize((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
3967 #endif
3968     }
3969     return pyobj;
3970 }
3971
3972
3973 static int _wrap_DialogNameStr_set(PyObject *) {
3974     PyErr_SetString(PyExc_TypeError,"Variable DialogNameStr is read-only.");
3975     return 1;
3976 }
3977
3978
3979 static PyObject *_wrap_DialogNameStr_get(void) {
3980     PyObject *pyobj;
3981
3982     {
3983 #if wxUSE_UNICODE
3984         pyobj = PyUnicode_FromWideChar((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
3985 #else
3986         pyobj = PyString_FromStringAndSize((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
3987 #endif
3988     }
3989     return pyobj;
3990 }
3991
3992
3993 static int _wrap_StatusLineNameStr_set(PyObject *) {
3994     PyErr_SetString(PyExc_TypeError,"Variable StatusLineNameStr is read-only.");
3995     return 1;
3996 }
3997
3998
3999 static PyObject *_wrap_StatusLineNameStr_get(void) {
4000     PyObject *pyobj;
4001
4002     {
4003 #if wxUSE_UNICODE
4004         pyobj = PyUnicode_FromWideChar((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4005 #else
4006         pyobj = PyString_FromStringAndSize((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4007 #endif
4008     }
4009     return pyobj;
4010 }
4011
4012
4013 static int _wrap_ToolBarNameStr_set(PyObject *) {
4014     PyErr_SetString(PyExc_TypeError,"Variable ToolBarNameStr is read-only.");
4015     return 1;
4016 }
4017
4018
4019 static PyObject *_wrap_ToolBarNameStr_get(void) {
4020     PyObject *pyobj;
4021
4022     {
4023 #if wxUSE_UNICODE
4024         pyobj = PyUnicode_FromWideChar((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4025 #else
4026         pyobj = PyString_FromStringAndSize((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4027 #endif
4028     }
4029     return pyobj;
4030 }
4031
4032
4033 static PyObject *_wrap_TopLevelWindow_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
4034     PyObject *resultobj;
4035     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4036     bool arg2 = (bool) true ;
4037     PyObject * obj0 = 0 ;
4038     PyObject * obj1 = 0 ;
4039     char *kwnames[] = {
4040         (char *) "self",(char *) "maximize", NULL
4041     };
4042
4043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Maximize",kwnames,&obj0,&obj1)) goto fail;
4044     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4045     if (SWIG_arg_fail(1)) SWIG_fail;
4046     if (obj1) {
4047         {
4048             arg2 = (bool)(SWIG_As_bool(obj1));
4049             if (SWIG_arg_fail(2)) SWIG_fail;
4050         }
4051     }
4052     {
4053         PyThreadState* __tstate = wxPyBeginAllowThreads();
4054         (arg1)->Maximize(arg2);
4055
4056         wxPyEndAllowThreads(__tstate);
4057         if (PyErr_Occurred()) SWIG_fail;
4058     }
4059     Py_INCREF(Py_None); resultobj = Py_None;
4060     return resultobj;
4061     fail:
4062     return NULL;
4063 }
4064
4065
4066 static PyObject *_wrap_TopLevelWindow_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
4067     PyObject *resultobj;
4068     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4069     PyObject * obj0 = 0 ;
4070     char *kwnames[] = {
4071         (char *) "self", NULL
4072     };
4073
4074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_Restore",kwnames,&obj0)) goto fail;
4075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4076     if (SWIG_arg_fail(1)) SWIG_fail;
4077     {
4078         PyThreadState* __tstate = wxPyBeginAllowThreads();
4079         (arg1)->Restore();
4080
4081         wxPyEndAllowThreads(__tstate);
4082         if (PyErr_Occurred()) SWIG_fail;
4083     }
4084     Py_INCREF(Py_None); resultobj = Py_None;
4085     return resultobj;
4086     fail:
4087     return NULL;
4088 }
4089
4090
4091 static PyObject *_wrap_TopLevelWindow_Iconize(PyObject *, PyObject *args, PyObject *kwargs) {
4092     PyObject *resultobj;
4093     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4094     bool arg2 = (bool) true ;
4095     PyObject * obj0 = 0 ;
4096     PyObject * obj1 = 0 ;
4097     char *kwnames[] = {
4098         (char *) "self",(char *) "iconize", NULL
4099     };
4100
4101     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Iconize",kwnames,&obj0,&obj1)) goto fail;
4102     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4103     if (SWIG_arg_fail(1)) SWIG_fail;
4104     if (obj1) {
4105         {
4106             arg2 = (bool)(SWIG_As_bool(obj1));
4107             if (SWIG_arg_fail(2)) SWIG_fail;
4108         }
4109     }
4110     {
4111         PyThreadState* __tstate = wxPyBeginAllowThreads();
4112         (arg1)->Iconize(arg2);
4113
4114         wxPyEndAllowThreads(__tstate);
4115         if (PyErr_Occurred()) SWIG_fail;
4116     }
4117     Py_INCREF(Py_None); resultobj = Py_None;
4118     return resultobj;
4119     fail:
4120     return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_TopLevelWindow_IsMaximized(PyObject *, PyObject *args, PyObject *kwargs) {
4125     PyObject *resultobj;
4126     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4127     bool result;
4128     PyObject * obj0 = 0 ;
4129     char *kwnames[] = {
4130         (char *) "self", NULL
4131     };
4132
4133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsMaximized",kwnames,&obj0)) goto fail;
4134     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4135     if (SWIG_arg_fail(1)) SWIG_fail;
4136     {
4137         PyThreadState* __tstate = wxPyBeginAllowThreads();
4138         result = (bool)((wxTopLevelWindow const *)arg1)->IsMaximized();
4139
4140         wxPyEndAllowThreads(__tstate);
4141         if (PyErr_Occurred()) SWIG_fail;
4142     }
4143     {
4144         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4145     }
4146     return resultobj;
4147     fail:
4148     return NULL;
4149 }
4150
4151
4152 static PyObject *_wrap_TopLevelWindow_IsIconized(PyObject *, PyObject *args, PyObject *kwargs) {
4153     PyObject *resultobj;
4154     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4155     bool result;
4156     PyObject * obj0 = 0 ;
4157     char *kwnames[] = {
4158         (char *) "self", NULL
4159     };
4160
4161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsIconized",kwnames,&obj0)) goto fail;
4162     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4163     if (SWIG_arg_fail(1)) SWIG_fail;
4164     {
4165         PyThreadState* __tstate = wxPyBeginAllowThreads();
4166         result = (bool)((wxTopLevelWindow const *)arg1)->IsIconized();
4167
4168         wxPyEndAllowThreads(__tstate);
4169         if (PyErr_Occurred()) SWIG_fail;
4170     }
4171     {
4172         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4173     }
4174     return resultobj;
4175     fail:
4176     return NULL;
4177 }
4178
4179
4180 static PyObject *_wrap_TopLevelWindow_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4181     PyObject *resultobj;
4182     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4183     wxIcon result;
4184     PyObject * obj0 = 0 ;
4185     char *kwnames[] = {
4186         (char *) "self", NULL
4187     };
4188
4189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetIcon",kwnames,&obj0)) goto fail;
4190     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4191     if (SWIG_arg_fail(1)) SWIG_fail;
4192     {
4193         PyThreadState* __tstate = wxPyBeginAllowThreads();
4194         result = ((wxTopLevelWindow const *)arg1)->GetIcon();
4195
4196         wxPyEndAllowThreads(__tstate);
4197         if (PyErr_Occurred()) SWIG_fail;
4198     }
4199     {
4200         wxIcon * resultptr;
4201         resultptr = new wxIcon((wxIcon &)(result));
4202         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
4203     }
4204     return resultobj;
4205     fail:
4206     return NULL;
4207 }
4208
4209
4210 static PyObject *_wrap_TopLevelWindow_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4211     PyObject *resultobj;
4212     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4213     wxIcon *arg2 = 0 ;
4214     PyObject * obj0 = 0 ;
4215     PyObject * obj1 = 0 ;
4216     char *kwnames[] = {
4217         (char *) "self",(char *) "icon", NULL
4218     };
4219
4220     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcon",kwnames,&obj0,&obj1)) goto fail;
4221     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4222     if (SWIG_arg_fail(1)) SWIG_fail;
4223     {
4224         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4225         if (SWIG_arg_fail(2)) SWIG_fail;
4226         if (arg2 == NULL) {
4227             SWIG_null_ref("wxIcon");
4228         }
4229         if (SWIG_arg_fail(2)) SWIG_fail;
4230     }
4231     {
4232         PyThreadState* __tstate = wxPyBeginAllowThreads();
4233         (arg1)->SetIcon((wxIcon const &)*arg2);
4234
4235         wxPyEndAllowThreads(__tstate);
4236         if (PyErr_Occurred()) SWIG_fail;
4237     }
4238     Py_INCREF(Py_None); resultobj = Py_None;
4239     return resultobj;
4240     fail:
4241     return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_TopLevelWindow_SetIcons(PyObject *, PyObject *args, PyObject *kwargs) {
4246     PyObject *resultobj;
4247     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4248     wxIconBundle *arg2 = 0 ;
4249     PyObject * obj0 = 0 ;
4250     PyObject * obj1 = 0 ;
4251     char *kwnames[] = {
4252         (char *) "self",(char *) "icons", NULL
4253     };
4254
4255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcons",kwnames,&obj0,&obj1)) goto fail;
4256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4257     if (SWIG_arg_fail(1)) SWIG_fail;
4258     {
4259         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
4260         if (SWIG_arg_fail(2)) SWIG_fail;
4261         if (arg2 == NULL) {
4262             SWIG_null_ref("wxIconBundle");
4263         }
4264         if (SWIG_arg_fail(2)) SWIG_fail;
4265     }
4266     {
4267         PyThreadState* __tstate = wxPyBeginAllowThreads();
4268         (arg1)->SetIcons((wxIconBundle const &)*arg2);
4269
4270         wxPyEndAllowThreads(__tstate);
4271         if (PyErr_Occurred()) SWIG_fail;
4272     }
4273     Py_INCREF(Py_None); resultobj = Py_None;
4274     return resultobj;
4275     fail:
4276     return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_TopLevelWindow_ShowFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4281     PyObject *resultobj;
4282     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4283     bool arg2 ;
4284     long arg3 = (long) wxFULLSCREEN_ALL ;
4285     bool result;
4286     PyObject * obj0 = 0 ;
4287     PyObject * obj1 = 0 ;
4288     PyObject * obj2 = 0 ;
4289     char *kwnames[] = {
4290         (char *) "self",(char *) "show",(char *) "style", NULL
4291     };
4292
4293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TopLevelWindow_ShowFullScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
4294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4295     if (SWIG_arg_fail(1)) SWIG_fail;
4296     {
4297         arg2 = (bool)(SWIG_As_bool(obj1));
4298         if (SWIG_arg_fail(2)) SWIG_fail;
4299     }
4300     if (obj2) {
4301         {
4302             arg3 = (long)(SWIG_As_long(obj2));
4303             if (SWIG_arg_fail(3)) SWIG_fail;
4304         }
4305     }
4306     {
4307         PyThreadState* __tstate = wxPyBeginAllowThreads();
4308         result = (bool)(arg1)->ShowFullScreen(arg2,arg3);
4309
4310         wxPyEndAllowThreads(__tstate);
4311         if (PyErr_Occurred()) SWIG_fail;
4312     }
4313     {
4314         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4315     }
4316     return resultobj;
4317     fail:
4318     return NULL;
4319 }
4320
4321
4322 static PyObject *_wrap_TopLevelWindow_IsFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4323     PyObject *resultobj;
4324     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4325     bool result;
4326     PyObject * obj0 = 0 ;
4327     char *kwnames[] = {
4328         (char *) "self", NULL
4329     };
4330
4331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsFullScreen",kwnames,&obj0)) goto fail;
4332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4333     if (SWIG_arg_fail(1)) SWIG_fail;
4334     {
4335         PyThreadState* __tstate = wxPyBeginAllowThreads();
4336         result = (bool)((wxTopLevelWindow const *)arg1)->IsFullScreen();
4337
4338         wxPyEndAllowThreads(__tstate);
4339         if (PyErr_Occurred()) SWIG_fail;
4340     }
4341     {
4342         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4343     }
4344     return resultobj;
4345     fail:
4346     return NULL;
4347 }
4348
4349
4350 static PyObject *_wrap_TopLevelWindow_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4351     PyObject *resultobj;
4352     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4353     wxString *arg2 = 0 ;
4354     bool temp2 = false ;
4355     PyObject * obj0 = 0 ;
4356     PyObject * obj1 = 0 ;
4357     char *kwnames[] = {
4358         (char *) "self",(char *) "title", NULL
4359     };
4360
4361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetTitle",kwnames,&obj0,&obj1)) goto fail;
4362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4363     if (SWIG_arg_fail(1)) SWIG_fail;
4364     {
4365         arg2 = wxString_in_helper(obj1);
4366         if (arg2 == NULL) SWIG_fail;
4367         temp2 = true;
4368     }
4369     {
4370         PyThreadState* __tstate = wxPyBeginAllowThreads();
4371         (arg1)->SetTitle((wxString const &)*arg2);
4372
4373         wxPyEndAllowThreads(__tstate);
4374         if (PyErr_Occurred()) SWIG_fail;
4375     }
4376     Py_INCREF(Py_None); resultobj = Py_None;
4377     {
4378         if (temp2)
4379         delete arg2;
4380     }
4381     return resultobj;
4382     fail:
4383     {
4384         if (temp2)
4385         delete arg2;
4386     }
4387     return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_TopLevelWindow_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4392     PyObject *resultobj;
4393     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4394     wxString result;
4395     PyObject * obj0 = 0 ;
4396     char *kwnames[] = {
4397         (char *) "self", NULL
4398     };
4399
4400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetTitle",kwnames,&obj0)) goto fail;
4401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4402     if (SWIG_arg_fail(1)) SWIG_fail;
4403     {
4404         PyThreadState* __tstate = wxPyBeginAllowThreads();
4405         result = ((wxTopLevelWindow const *)arg1)->GetTitle();
4406
4407         wxPyEndAllowThreads(__tstate);
4408         if (PyErr_Occurred()) SWIG_fail;
4409     }
4410     {
4411 #if wxUSE_UNICODE
4412         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4413 #else
4414         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4415 #endif
4416     }
4417     return resultobj;
4418     fail:
4419     return NULL;
4420 }
4421
4422
4423 static PyObject *_wrap_TopLevelWindow_SetShape(PyObject *, PyObject *args, PyObject *kwargs) {
4424     PyObject *resultobj;
4425     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4426     wxRegion *arg2 = 0 ;
4427     bool result;
4428     PyObject * obj0 = 0 ;
4429     PyObject * obj1 = 0 ;
4430     char *kwnames[] = {
4431         (char *) "self",(char *) "region", NULL
4432     };
4433
4434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetShape",kwnames,&obj0,&obj1)) goto fail;
4435     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4436     if (SWIG_arg_fail(1)) SWIG_fail;
4437     {
4438         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
4439         if (SWIG_arg_fail(2)) SWIG_fail;
4440         if (arg2 == NULL) {
4441             SWIG_null_ref("wxRegion");
4442         }
4443         if (SWIG_arg_fail(2)) SWIG_fail;
4444     }
4445     {
4446         PyThreadState* __tstate = wxPyBeginAllowThreads();
4447         result = (bool)(arg1)->SetShape((wxRegion const &)*arg2);
4448
4449         wxPyEndAllowThreads(__tstate);
4450         if (PyErr_Occurred()) SWIG_fail;
4451     }
4452     {
4453         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4454     }
4455     return resultobj;
4456     fail:
4457     return NULL;
4458 }
4459
4460
4461 static PyObject *_wrap_TopLevelWindow_RequestUserAttention(PyObject *, PyObject *args, PyObject *kwargs) {
4462     PyObject *resultobj;
4463     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4464     int arg2 = (int) wxUSER_ATTENTION_INFO ;
4465     PyObject * obj0 = 0 ;
4466     PyObject * obj1 = 0 ;
4467     char *kwnames[] = {
4468         (char *) "self",(char *) "flags", NULL
4469     };
4470
4471     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_RequestUserAttention",kwnames,&obj0,&obj1)) goto fail;
4472     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4473     if (SWIG_arg_fail(1)) SWIG_fail;
4474     if (obj1) {
4475         {
4476             arg2 = (int)(SWIG_As_int(obj1));
4477             if (SWIG_arg_fail(2)) SWIG_fail;
4478         }
4479     }
4480     {
4481         PyThreadState* __tstate = wxPyBeginAllowThreads();
4482         (arg1)->RequestUserAttention(arg2);
4483
4484         wxPyEndAllowThreads(__tstate);
4485         if (PyErr_Occurred()) SWIG_fail;
4486     }
4487     Py_INCREF(Py_None); resultobj = Py_None;
4488     return resultobj;
4489     fail:
4490     return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_TopLevelWindow_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
4495     PyObject *resultobj;
4496     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4497     bool result;
4498     PyObject * obj0 = 0 ;
4499     char *kwnames[] = {
4500         (char *) "self", NULL
4501     };
4502
4503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsActive",kwnames,&obj0)) goto fail;
4504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4505     if (SWIG_arg_fail(1)) SWIG_fail;
4506     {
4507         PyThreadState* __tstate = wxPyBeginAllowThreads();
4508         result = (bool)(arg1)->IsActive();
4509
4510         wxPyEndAllowThreads(__tstate);
4511         if (PyErr_Occurred()) SWIG_fail;
4512     }
4513     {
4514         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4515     }
4516     return resultobj;
4517     fail:
4518     return NULL;
4519 }
4520
4521
4522 static PyObject *_wrap_TopLevelWindow_MacSetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4523     PyObject *resultobj;
4524     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4525     bool arg2 ;
4526     PyObject * obj0 = 0 ;
4527     PyObject * obj1 = 0 ;
4528     char *kwnames[] = {
4529         (char *) "self",(char *) "on", NULL
4530     };
4531
4532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_MacSetMetalAppearance",kwnames,&obj0,&obj1)) goto fail;
4533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4534     if (SWIG_arg_fail(1)) SWIG_fail;
4535     {
4536         arg2 = (bool)(SWIG_As_bool(obj1));
4537         if (SWIG_arg_fail(2)) SWIG_fail;
4538     }
4539     {
4540         PyThreadState* __tstate = wxPyBeginAllowThreads();
4541         wxTopLevelWindow_MacSetMetalAppearance(arg1,arg2);
4542
4543         wxPyEndAllowThreads(__tstate);
4544         if (PyErr_Occurred()) SWIG_fail;
4545     }
4546     Py_INCREF(Py_None); resultobj = Py_None;
4547     return resultobj;
4548     fail:
4549     return NULL;
4550 }
4551
4552
4553 static PyObject *_wrap_TopLevelWindow_MacGetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4554     PyObject *resultobj;
4555     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4556     bool result;
4557     PyObject * obj0 = 0 ;
4558     char *kwnames[] = {
4559         (char *) "self", NULL
4560     };
4561
4562     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_MacGetMetalAppearance",kwnames,&obj0)) goto fail;
4563     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4564     if (SWIG_arg_fail(1)) SWIG_fail;
4565     {
4566         PyThreadState* __tstate = wxPyBeginAllowThreads();
4567         result = (bool)wxTopLevelWindow_MacGetMetalAppearance((wxTopLevelWindow const *)arg1);
4568
4569         wxPyEndAllowThreads(__tstate);
4570         if (PyErr_Occurred()) SWIG_fail;
4571     }
4572     {
4573         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4574     }
4575     return resultobj;
4576     fail:
4577     return NULL;
4578 }
4579
4580
4581 static PyObject * TopLevelWindow_swigregister(PyObject *, PyObject *args) {
4582     PyObject *obj;
4583     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4584     SWIG_TypeClientData(SWIGTYPE_p_wxTopLevelWindow, obj);
4585     Py_INCREF(obj);
4586     return Py_BuildValue((char *)"");
4587 }
4588 static PyObject *_wrap_new_Frame(PyObject *, PyObject *args, PyObject *kwargs) {
4589     PyObject *resultobj;
4590     wxWindow *arg1 = (wxWindow *) 0 ;
4591     int arg2 = (int) (int)-1 ;
4592     wxString const &arg3_defvalue = wxPyEmptyString ;
4593     wxString *arg3 = (wxString *) &arg3_defvalue ;
4594     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4595     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4596     wxSize const &arg5_defvalue = wxDefaultSize ;
4597     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4598     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
4599     wxString const &arg7_defvalue = wxPyFrameNameStr ;
4600     wxString *arg7 = (wxString *) &arg7_defvalue ;
4601     wxFrame *result;
4602     bool temp3 = false ;
4603     wxPoint temp4 ;
4604     wxSize temp5 ;
4605     bool temp7 = false ;
4606     PyObject * obj0 = 0 ;
4607     PyObject * obj1 = 0 ;
4608     PyObject * obj2 = 0 ;
4609     PyObject * obj3 = 0 ;
4610     PyObject * obj4 = 0 ;
4611     PyObject * obj5 = 0 ;
4612     PyObject * obj6 = 0 ;
4613     char *kwnames[] = {
4614         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4615     };
4616
4617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Frame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4619     if (SWIG_arg_fail(1)) SWIG_fail;
4620     if (obj1) {
4621         {
4622             arg2 = (int const)(SWIG_As_int(obj1));
4623             if (SWIG_arg_fail(2)) SWIG_fail;
4624         }
4625     }
4626     if (obj2) {
4627         {
4628             arg3 = wxString_in_helper(obj2);
4629             if (arg3 == NULL) SWIG_fail;
4630             temp3 = true;
4631         }
4632     }
4633     if (obj3) {
4634         {
4635             arg4 = &temp4;
4636             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4637         }
4638     }
4639     if (obj4) {
4640         {
4641             arg5 = &temp5;
4642             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4643         }
4644     }
4645     if (obj5) {
4646         {
4647             arg6 = (long)(SWIG_As_long(obj5));
4648             if (SWIG_arg_fail(6)) SWIG_fail;
4649         }
4650     }
4651     if (obj6) {
4652         {
4653             arg7 = wxString_in_helper(obj6);
4654             if (arg7 == NULL) SWIG_fail;
4655             temp7 = true;
4656         }
4657     }
4658     {
4659         if (!wxPyCheckForApp()) SWIG_fail;
4660         PyThreadState* __tstate = wxPyBeginAllowThreads();
4661         result = (wxFrame *)new wxFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
4662
4663         wxPyEndAllowThreads(__tstate);
4664         if (PyErr_Occurred()) SWIG_fail;
4665     }
4666     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4667     {
4668         if (temp3)
4669         delete arg3;
4670     }
4671     {
4672         if (temp7)
4673         delete arg7;
4674     }
4675     return resultobj;
4676     fail:
4677     {
4678         if (temp3)
4679         delete arg3;
4680     }
4681     {
4682         if (temp7)
4683         delete arg7;
4684     }
4685     return NULL;
4686 }
4687
4688
4689 static PyObject *_wrap_new_PreFrame(PyObject *, PyObject *args, PyObject *kwargs) {
4690     PyObject *resultobj;
4691     wxFrame *result;
4692     char *kwnames[] = {
4693         NULL
4694     };
4695
4696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFrame",kwnames)) goto fail;
4697     {
4698         if (!wxPyCheckForApp()) SWIG_fail;
4699         PyThreadState* __tstate = wxPyBeginAllowThreads();
4700         result = (wxFrame *)new wxFrame();
4701
4702         wxPyEndAllowThreads(__tstate);
4703         if (PyErr_Occurred()) SWIG_fail;
4704     }
4705     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4706     return resultobj;
4707     fail:
4708     return NULL;
4709 }
4710
4711
4712 static PyObject *_wrap_Frame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4713     PyObject *resultobj;
4714     wxFrame *arg1 = (wxFrame *) 0 ;
4715     wxWindow *arg2 = (wxWindow *) 0 ;
4716     int arg3 = (int) (int)-1 ;
4717     wxString const &arg4_defvalue = wxPyEmptyString ;
4718     wxString *arg4 = (wxString *) &arg4_defvalue ;
4719     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4720     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4721     wxSize const &arg6_defvalue = wxDefaultSize ;
4722     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4723     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
4724     wxString const &arg8_defvalue = wxPyFrameNameStr ;
4725     wxString *arg8 = (wxString *) &arg8_defvalue ;
4726     bool result;
4727     bool temp4 = false ;
4728     wxPoint temp5 ;
4729     wxSize temp6 ;
4730     bool temp8 = false ;
4731     PyObject * obj0 = 0 ;
4732     PyObject * obj1 = 0 ;
4733     PyObject * obj2 = 0 ;
4734     PyObject * obj3 = 0 ;
4735     PyObject * obj4 = 0 ;
4736     PyObject * obj5 = 0 ;
4737     PyObject * obj6 = 0 ;
4738     PyObject * obj7 = 0 ;
4739     char *kwnames[] = {
4740         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4741     };
4742
4743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Frame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4744     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4745     if (SWIG_arg_fail(1)) SWIG_fail;
4746     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4747     if (SWIG_arg_fail(2)) SWIG_fail;
4748     if (obj2) {
4749         {
4750             arg3 = (int const)(SWIG_As_int(obj2));
4751             if (SWIG_arg_fail(3)) SWIG_fail;
4752         }
4753     }
4754     if (obj3) {
4755         {
4756             arg4 = wxString_in_helper(obj3);
4757             if (arg4 == NULL) SWIG_fail;
4758             temp4 = true;
4759         }
4760     }
4761     if (obj4) {
4762         {
4763             arg5 = &temp5;
4764             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4765         }
4766     }
4767     if (obj5) {
4768         {
4769             arg6 = &temp6;
4770             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4771         }
4772     }
4773     if (obj6) {
4774         {
4775             arg7 = (long)(SWIG_As_long(obj6));
4776             if (SWIG_arg_fail(7)) SWIG_fail;
4777         }
4778     }
4779     if (obj7) {
4780         {
4781             arg8 = wxString_in_helper(obj7);
4782             if (arg8 == NULL) SWIG_fail;
4783             temp8 = true;
4784         }
4785     }
4786     {
4787         PyThreadState* __tstate = wxPyBeginAllowThreads();
4788         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
4789
4790         wxPyEndAllowThreads(__tstate);
4791         if (PyErr_Occurred()) SWIG_fail;
4792     }
4793     {
4794         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4795     }
4796     {
4797         if (temp4)
4798         delete arg4;
4799     }
4800     {
4801         if (temp8)
4802         delete arg8;
4803     }
4804     return resultobj;
4805     fail:
4806     {
4807         if (temp4)
4808         delete arg4;
4809     }
4810     {
4811         if (temp8)
4812         delete arg8;
4813     }
4814     return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_Frame_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
4819     PyObject *resultobj;
4820     wxFrame *arg1 = (wxFrame *) 0 ;
4821     wxPoint result;
4822     PyObject * obj0 = 0 ;
4823     char *kwnames[] = {
4824         (char *) "self", NULL
4825     };
4826
4827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
4828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4829     if (SWIG_arg_fail(1)) SWIG_fail;
4830     {
4831         PyThreadState* __tstate = wxPyBeginAllowThreads();
4832         result = ((wxFrame const *)arg1)->GetClientAreaOrigin();
4833
4834         wxPyEndAllowThreads(__tstate);
4835         if (PyErr_Occurred()) SWIG_fail;
4836     }
4837     {
4838         wxPoint * resultptr;
4839         resultptr = new wxPoint((wxPoint &)(result));
4840         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4841     }
4842     return resultobj;
4843     fail:
4844     return NULL;
4845 }
4846
4847
4848 static PyObject *_wrap_Frame_SendSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
4849     PyObject *resultobj;
4850     wxFrame *arg1 = (wxFrame *) 0 ;
4851     PyObject * obj0 = 0 ;
4852     char *kwnames[] = {
4853         (char *) "self", NULL
4854     };
4855
4856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_SendSizeEvent",kwnames,&obj0)) goto fail;
4857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4858     if (SWIG_arg_fail(1)) SWIG_fail;
4859     {
4860         PyThreadState* __tstate = wxPyBeginAllowThreads();
4861         (arg1)->SendSizeEvent();
4862
4863         wxPyEndAllowThreads(__tstate);
4864         if (PyErr_Occurred()) SWIG_fail;
4865     }
4866     Py_INCREF(Py_None); resultobj = Py_None;
4867     return resultobj;
4868     fail:
4869     return NULL;
4870 }
4871
4872
4873 static PyObject *_wrap_Frame_SetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4874     PyObject *resultobj;
4875     wxFrame *arg1 = (wxFrame *) 0 ;
4876     wxMenuBar *arg2 = (wxMenuBar *) 0 ;
4877     PyObject * obj0 = 0 ;
4878     PyObject * obj1 = 0 ;
4879     char *kwnames[] = {
4880         (char *) "self",(char *) "menubar", NULL
4881     };
4882
4883     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetMenuBar",kwnames,&obj0,&obj1)) goto fail;
4884     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4885     if (SWIG_arg_fail(1)) SWIG_fail;
4886     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
4887     if (SWIG_arg_fail(2)) SWIG_fail;
4888     {
4889         PyThreadState* __tstate = wxPyBeginAllowThreads();
4890         (arg1)->SetMenuBar(arg2);
4891
4892         wxPyEndAllowThreads(__tstate);
4893         if (PyErr_Occurred()) SWIG_fail;
4894     }
4895     Py_INCREF(Py_None); resultobj = Py_None;
4896     return resultobj;
4897     fail:
4898     return NULL;
4899 }
4900
4901
4902 static PyObject *_wrap_Frame_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4903     PyObject *resultobj;
4904     wxFrame *arg1 = (wxFrame *) 0 ;
4905     wxMenuBar *result;
4906     PyObject * obj0 = 0 ;
4907     char *kwnames[] = {
4908         (char *) "self", NULL
4909     };
4910
4911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetMenuBar",kwnames,&obj0)) goto fail;
4912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4913     if (SWIG_arg_fail(1)) SWIG_fail;
4914     {
4915         PyThreadState* __tstate = wxPyBeginAllowThreads();
4916         result = (wxMenuBar *)((wxFrame const *)arg1)->GetMenuBar();
4917
4918         wxPyEndAllowThreads(__tstate);
4919         if (PyErr_Occurred()) SWIG_fail;
4920     }
4921     {
4922         resultobj = wxPyMake_wxObject(result, 0);
4923     }
4924     return resultobj;
4925     fail:
4926     return NULL;
4927 }
4928
4929
4930 static PyObject *_wrap_Frame_ProcessCommand(PyObject *, PyObject *args, PyObject *kwargs) {
4931     PyObject *resultobj;
4932     wxFrame *arg1 = (wxFrame *) 0 ;
4933     int arg2 ;
4934     bool result;
4935     PyObject * obj0 = 0 ;
4936     PyObject * obj1 = 0 ;
4937     char *kwnames[] = {
4938         (char *) "self",(char *) "winid", NULL
4939     };
4940
4941     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_ProcessCommand",kwnames,&obj0,&obj1)) goto fail;
4942     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4943     if (SWIG_arg_fail(1)) SWIG_fail;
4944     {
4945         arg2 = (int)(SWIG_As_int(obj1));
4946         if (SWIG_arg_fail(2)) SWIG_fail;
4947     }
4948     {
4949         PyThreadState* __tstate = wxPyBeginAllowThreads();
4950         result = (bool)(arg1)->ProcessCommand(arg2);
4951
4952         wxPyEndAllowThreads(__tstate);
4953         if (PyErr_Occurred()) SWIG_fail;
4954     }
4955     {
4956         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4957     }
4958     return resultobj;
4959     fail:
4960     return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Frame_CreateStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
4965     PyObject *resultobj;
4966     wxFrame *arg1 = (wxFrame *) 0 ;
4967     int arg2 = (int) 1 ;
4968     long arg3 = (long) wxST_SIZEGRIP|wxFULL_REPAINT_ON_RESIZE ;
4969     int arg4 = (int) 0 ;
4970     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
4971     wxString *arg5 = (wxString *) &arg5_defvalue ;
4972     wxStatusBar *result;
4973     bool temp5 = false ;
4974     PyObject * obj0 = 0 ;
4975     PyObject * obj1 = 0 ;
4976     PyObject * obj2 = 0 ;
4977     PyObject * obj3 = 0 ;
4978     PyObject * obj4 = 0 ;
4979     char *kwnames[] = {
4980         (char *) "self",(char *) "number",(char *) "style",(char *) "winid",(char *) "name", NULL
4981     };
4982
4983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Frame_CreateStatusBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4985     if (SWIG_arg_fail(1)) SWIG_fail;
4986     if (obj1) {
4987         {
4988             arg2 = (int)(SWIG_As_int(obj1));
4989             if (SWIG_arg_fail(2)) SWIG_fail;
4990         }
4991     }
4992     if (obj2) {
4993         {
4994             arg3 = (long)(SWIG_As_long(obj2));
4995             if (SWIG_arg_fail(3)) SWIG_fail;
4996         }
4997     }
4998     if (obj3) {
4999         {
5000             arg4 = (int)(SWIG_As_int(obj3));
5001             if (SWIG_arg_fail(4)) SWIG_fail;
5002         }
5003     }
5004     if (obj4) {
5005         {
5006             arg5 = wxString_in_helper(obj4);
5007             if (arg5 == NULL) SWIG_fail;
5008             temp5 = true;
5009         }
5010     }
5011     {
5012         PyThreadState* __tstate = wxPyBeginAllowThreads();
5013         result = (wxStatusBar *)(arg1)->CreateStatusBar(arg2,arg3,arg4,(wxString const &)*arg5);
5014
5015         wxPyEndAllowThreads(__tstate);
5016         if (PyErr_Occurred()) SWIG_fail;
5017     }
5018     {
5019         resultobj = wxPyMake_wxObject(result, 0);
5020     }
5021     {
5022         if (temp5)
5023         delete arg5;
5024     }
5025     return resultobj;
5026     fail:
5027     {
5028         if (temp5)
5029         delete arg5;
5030     }
5031     return NULL;
5032 }
5033
5034
5035 static PyObject *_wrap_Frame_GetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5036     PyObject *resultobj;
5037     wxFrame *arg1 = (wxFrame *) 0 ;
5038     wxStatusBar *result;
5039     PyObject * obj0 = 0 ;
5040     char *kwnames[] = {
5041         (char *) "self", NULL
5042     };
5043
5044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBar",kwnames,&obj0)) goto fail;
5045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5046     if (SWIG_arg_fail(1)) SWIG_fail;
5047     {
5048         PyThreadState* __tstate = wxPyBeginAllowThreads();
5049         result = (wxStatusBar *)((wxFrame const *)arg1)->GetStatusBar();
5050
5051         wxPyEndAllowThreads(__tstate);
5052         if (PyErr_Occurred()) SWIG_fail;
5053     }
5054     {
5055         resultobj = wxPyMake_wxObject(result, 0);
5056     }
5057     return resultobj;
5058     fail:
5059     return NULL;
5060 }
5061
5062
5063 static PyObject *_wrap_Frame_SetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5064     PyObject *resultobj;
5065     wxFrame *arg1 = (wxFrame *) 0 ;
5066     wxStatusBar *arg2 = (wxStatusBar *) 0 ;
5067     PyObject * obj0 = 0 ;
5068     PyObject * obj1 = 0 ;
5069     char *kwnames[] = {
5070         (char *) "self",(char *) "statBar", NULL
5071     };
5072
5073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBar",kwnames,&obj0,&obj1)) goto fail;
5074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5075     if (SWIG_arg_fail(1)) SWIG_fail;
5076     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
5077     if (SWIG_arg_fail(2)) SWIG_fail;
5078     {
5079         PyThreadState* __tstate = wxPyBeginAllowThreads();
5080         (arg1)->SetStatusBar(arg2);
5081
5082         wxPyEndAllowThreads(__tstate);
5083         if (PyErr_Occurred()) SWIG_fail;
5084     }
5085     Py_INCREF(Py_None); resultobj = Py_None;
5086     return resultobj;
5087     fail:
5088     return NULL;
5089 }
5090
5091
5092 static PyObject *_wrap_Frame_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5093     PyObject *resultobj;
5094     wxFrame *arg1 = (wxFrame *) 0 ;
5095     wxString *arg2 = 0 ;
5096     int arg3 = (int) 0 ;
5097     bool temp2 = false ;
5098     PyObject * obj0 = 0 ;
5099     PyObject * obj1 = 0 ;
5100     PyObject * obj2 = 0 ;
5101     char *kwnames[] = {
5102         (char *) "self",(char *) "text",(char *) "number", NULL
5103     };
5104
5105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5106     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5107     if (SWIG_arg_fail(1)) SWIG_fail;
5108     {
5109         arg2 = wxString_in_helper(obj1);
5110         if (arg2 == NULL) SWIG_fail;
5111         temp2 = true;
5112     }
5113     if (obj2) {
5114         {
5115             arg3 = (int)(SWIG_As_int(obj2));
5116             if (SWIG_arg_fail(3)) SWIG_fail;
5117         }
5118     }
5119     {
5120         PyThreadState* __tstate = wxPyBeginAllowThreads();
5121         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
5122
5123         wxPyEndAllowThreads(__tstate);
5124         if (PyErr_Occurred()) SWIG_fail;
5125     }
5126     Py_INCREF(Py_None); resultobj = Py_None;
5127     {
5128         if (temp2)
5129         delete arg2;
5130     }
5131     return resultobj;
5132     fail:
5133     {
5134         if (temp2)
5135         delete arg2;
5136     }
5137     return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_Frame_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
5142     PyObject *resultobj;
5143     wxFrame *arg1 = (wxFrame *) 0 ;
5144     int arg2 ;
5145     int *arg3 = (int *) 0 ;
5146     PyObject * obj0 = 0 ;
5147     PyObject * obj1 = 0 ;
5148     char *kwnames[] = {
5149         (char *) "self",(char *) "widths", NULL
5150     };
5151
5152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
5153     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5154     if (SWIG_arg_fail(1)) SWIG_fail;
5155     {
5156         arg2 = PyList_Size(obj1);
5157         arg3 =  int_LIST_helper(obj1);
5158         if (arg3 == NULL) SWIG_fail;
5159     }
5160     {
5161         PyThreadState* __tstate = wxPyBeginAllowThreads();
5162         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
5163
5164         wxPyEndAllowThreads(__tstate);
5165         if (PyErr_Occurred()) SWIG_fail;
5166     }
5167     Py_INCREF(Py_None); resultobj = Py_None;
5168     {
5169         if (arg3) delete [] arg3;
5170     }
5171     return resultobj;
5172     fail:
5173     {
5174         if (arg3) delete [] arg3;
5175     }
5176     return NULL;
5177 }
5178
5179
5180 static PyObject *_wrap_Frame_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5181     PyObject *resultobj;
5182     wxFrame *arg1 = (wxFrame *) 0 ;
5183     wxString *arg2 = 0 ;
5184     int arg3 = (int) 0 ;
5185     bool temp2 = false ;
5186     PyObject * obj0 = 0 ;
5187     PyObject * obj1 = 0 ;
5188     PyObject * obj2 = 0 ;
5189     char *kwnames[] = {
5190         (char *) "self",(char *) "text",(char *) "number", NULL
5191     };
5192
5193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5195     if (SWIG_arg_fail(1)) SWIG_fail;
5196     {
5197         arg2 = wxString_in_helper(obj1);
5198         if (arg2 == NULL) SWIG_fail;
5199         temp2 = true;
5200     }
5201     if (obj2) {
5202         {
5203             arg3 = (int)(SWIG_As_int(obj2));
5204             if (SWIG_arg_fail(3)) SWIG_fail;
5205         }
5206     }
5207     {
5208         PyThreadState* __tstate = wxPyBeginAllowThreads();
5209         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
5210
5211         wxPyEndAllowThreads(__tstate);
5212         if (PyErr_Occurred()) SWIG_fail;
5213     }
5214     Py_INCREF(Py_None); resultobj = Py_None;
5215     {
5216         if (temp2)
5217         delete arg2;
5218     }
5219     return resultobj;
5220     fail:
5221     {
5222         if (temp2)
5223         delete arg2;
5224     }
5225     return NULL;
5226 }
5227
5228
5229 static PyObject *_wrap_Frame_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5230     PyObject *resultobj;
5231     wxFrame *arg1 = (wxFrame *) 0 ;
5232     int arg2 = (int) 0 ;
5233     PyObject * obj0 = 0 ;
5234     PyObject * obj1 = 0 ;
5235     char *kwnames[] = {
5236         (char *) "self",(char *) "number", NULL
5237     };
5238
5239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
5240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5241     if (SWIG_arg_fail(1)) SWIG_fail;
5242     if (obj1) {
5243         {
5244             arg2 = (int)(SWIG_As_int(obj1));
5245             if (SWIG_arg_fail(2)) SWIG_fail;
5246         }
5247     }
5248     {
5249         PyThreadState* __tstate = wxPyBeginAllowThreads();
5250         (arg1)->PopStatusText(arg2);
5251
5252         wxPyEndAllowThreads(__tstate);
5253         if (PyErr_Occurred()) SWIG_fail;
5254     }
5255     Py_INCREF(Py_None); resultobj = Py_None;
5256     return resultobj;
5257     fail:
5258     return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Frame_SetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5263     PyObject *resultobj;
5264     wxFrame *arg1 = (wxFrame *) 0 ;
5265     int arg2 ;
5266     PyObject * obj0 = 0 ;
5267     PyObject * obj1 = 0 ;
5268     char *kwnames[] = {
5269         (char *) "self",(char *) "n", NULL
5270     };
5271
5272     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBarPane",kwnames,&obj0,&obj1)) goto fail;
5273     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5274     if (SWIG_arg_fail(1)) SWIG_fail;
5275     {
5276         arg2 = (int)(SWIG_As_int(obj1));
5277         if (SWIG_arg_fail(2)) SWIG_fail;
5278     }
5279     {
5280         PyThreadState* __tstate = wxPyBeginAllowThreads();
5281         (arg1)->SetStatusBarPane(arg2);
5282
5283         wxPyEndAllowThreads(__tstate);
5284         if (PyErr_Occurred()) SWIG_fail;
5285     }
5286     Py_INCREF(Py_None); resultobj = Py_None;
5287     return resultobj;
5288     fail:
5289     return NULL;
5290 }
5291
5292
5293 static PyObject *_wrap_Frame_GetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5294     PyObject *resultobj;
5295     wxFrame *arg1 = (wxFrame *) 0 ;
5296     int result;
5297     PyObject * obj0 = 0 ;
5298     char *kwnames[] = {
5299         (char *) "self", NULL
5300     };
5301
5302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBarPane",kwnames,&obj0)) goto fail;
5303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5304     if (SWIG_arg_fail(1)) SWIG_fail;
5305     {
5306         PyThreadState* __tstate = wxPyBeginAllowThreads();
5307         result = (int)((wxFrame const *)arg1)->GetStatusBarPane();
5308
5309         wxPyEndAllowThreads(__tstate);
5310         if (PyErr_Occurred()) SWIG_fail;
5311     }
5312     {
5313         resultobj = SWIG_From_int((int)(result));
5314     }
5315     return resultobj;
5316     fail:
5317     return NULL;
5318 }
5319
5320
5321 static PyObject *_wrap_Frame_CreateToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5322     PyObject *resultobj;
5323     wxFrame *arg1 = (wxFrame *) 0 ;
5324     long arg2 = (long) -1 ;
5325     int arg3 = (int) -1 ;
5326     wxString const &arg4_defvalue = wxPyToolBarNameStr ;
5327     wxString *arg4 = (wxString *) &arg4_defvalue ;
5328     wxToolBar *result;
5329     bool temp4 = false ;
5330     PyObject * obj0 = 0 ;
5331     PyObject * obj1 = 0 ;
5332     PyObject * obj2 = 0 ;
5333     PyObject * obj3 = 0 ;
5334     char *kwnames[] = {
5335         (char *) "self",(char *) "style",(char *) "winid",(char *) "name", NULL
5336     };
5337
5338     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Frame_CreateToolBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5339     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5340     if (SWIG_arg_fail(1)) SWIG_fail;
5341     if (obj1) {
5342         {
5343             arg2 = (long)(SWIG_As_long(obj1));
5344             if (SWIG_arg_fail(2)) SWIG_fail;
5345         }
5346     }
5347     if (obj2) {
5348         {
5349             arg3 = (int)(SWIG_As_int(obj2));
5350             if (SWIG_arg_fail(3)) SWIG_fail;
5351         }
5352     }
5353     if (obj3) {
5354         {
5355             arg4 = wxString_in_helper(obj3);
5356             if (arg4 == NULL) SWIG_fail;
5357             temp4 = true;
5358         }
5359     }
5360     {
5361         PyThreadState* __tstate = wxPyBeginAllowThreads();
5362         result = (wxToolBar *)(arg1)->CreateToolBar(arg2,arg3,(wxString const &)*arg4);
5363
5364         wxPyEndAllowThreads(__tstate);
5365         if (PyErr_Occurred()) SWIG_fail;
5366     }
5367     {
5368         resultobj = wxPyMake_wxObject(result, 0);
5369     }
5370     {
5371         if (temp4)
5372         delete arg4;
5373     }
5374     return resultobj;
5375     fail:
5376     {
5377         if (temp4)
5378         delete arg4;
5379     }
5380     return NULL;
5381 }
5382
5383
5384 static PyObject *_wrap_Frame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5385     PyObject *resultobj;
5386     wxFrame *arg1 = (wxFrame *) 0 ;
5387     wxToolBar *result;
5388     PyObject * obj0 = 0 ;
5389     char *kwnames[] = {
5390         (char *) "self", NULL
5391     };
5392
5393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetToolBar",kwnames,&obj0)) goto fail;
5394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5395     if (SWIG_arg_fail(1)) SWIG_fail;
5396     {
5397         PyThreadState* __tstate = wxPyBeginAllowThreads();
5398         result = (wxToolBar *)((wxFrame const *)arg1)->GetToolBar();
5399
5400         wxPyEndAllowThreads(__tstate);
5401         if (PyErr_Occurred()) SWIG_fail;
5402     }
5403     {
5404         resultobj = wxPyMake_wxObject(result, 0);
5405     }
5406     return resultobj;
5407     fail:
5408     return NULL;
5409 }
5410
5411
5412 static PyObject *_wrap_Frame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5413     PyObject *resultobj;
5414     wxFrame *arg1 = (wxFrame *) 0 ;
5415     wxToolBar *arg2 = (wxToolBar *) 0 ;
5416     PyObject * obj0 = 0 ;
5417     PyObject * obj1 = 0 ;
5418     char *kwnames[] = {
5419         (char *) "self",(char *) "toolbar", NULL
5420     };
5421
5422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
5423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5424     if (SWIG_arg_fail(1)) SWIG_fail;
5425     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
5426     if (SWIG_arg_fail(2)) SWIG_fail;
5427     {
5428         PyThreadState* __tstate = wxPyBeginAllowThreads();
5429         (arg1)->SetToolBar(arg2);
5430
5431         wxPyEndAllowThreads(__tstate);
5432         if (PyErr_Occurred()) SWIG_fail;
5433     }
5434     Py_INCREF(Py_None); resultobj = Py_None;
5435     return resultobj;
5436     fail:
5437     return NULL;
5438 }
5439
5440
5441 static PyObject *_wrap_Frame_DoGiveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
5442     PyObject *resultobj;
5443     wxFrame *arg1 = (wxFrame *) 0 ;
5444     wxString *arg2 = 0 ;
5445     bool arg3 ;
5446     bool temp2 = false ;
5447     PyObject * obj0 = 0 ;
5448     PyObject * obj1 = 0 ;
5449     PyObject * obj2 = 0 ;
5450     char *kwnames[] = {
5451         (char *) "self",(char *) "text",(char *) "show", NULL
5452     };
5453
5454     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Frame_DoGiveHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
5455     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5456     if (SWIG_arg_fail(1)) SWIG_fail;
5457     {
5458         arg2 = wxString_in_helper(obj1);
5459         if (arg2 == NULL) SWIG_fail;
5460         temp2 = true;
5461     }
5462     {
5463         arg3 = (bool)(SWIG_As_bool(obj2));
5464         if (SWIG_arg_fail(3)) SWIG_fail;
5465     }
5466     {
5467         PyThreadState* __tstate = wxPyBeginAllowThreads();
5468         (arg1)->DoGiveHelp((wxString const &)*arg2,arg3);
5469
5470         wxPyEndAllowThreads(__tstate);
5471         if (PyErr_Occurred()) SWIG_fail;
5472     }
5473     Py_INCREF(Py_None); resultobj = Py_None;
5474     {
5475         if (temp2)
5476         delete arg2;
5477     }
5478     return resultobj;
5479     fail:
5480     {
5481         if (temp2)
5482         delete arg2;
5483     }
5484     return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_Frame_DoMenuUpdates(PyObject *, PyObject *args, PyObject *kwargs) {
5489     PyObject *resultobj;
5490     wxFrame *arg1 = (wxFrame *) 0 ;
5491     wxMenu *arg2 = (wxMenu *) NULL ;
5492     PyObject * obj0 = 0 ;
5493     PyObject * obj1 = 0 ;
5494     char *kwnames[] = {
5495         (char *) "self",(char *) "menu", NULL
5496     };
5497
5498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_DoMenuUpdates",kwnames,&obj0,&obj1)) goto fail;
5499     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5500     if (SWIG_arg_fail(1)) SWIG_fail;
5501     if (obj1) {
5502         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
5503         if (SWIG_arg_fail(2)) SWIG_fail;
5504     }
5505     {
5506         PyThreadState* __tstate = wxPyBeginAllowThreads();
5507         (arg1)->DoMenuUpdates(arg2);
5508
5509         wxPyEndAllowThreads(__tstate);
5510         if (PyErr_Occurred()) SWIG_fail;
5511     }
5512     Py_INCREF(Py_None); resultobj = Py_None;
5513     return resultobj;
5514     fail:
5515     return NULL;
5516 }
5517
5518
5519 static PyObject *_wrap_Frame_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5520     PyObject *resultobj;
5521     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5522     wxVisualAttributes result;
5523     PyObject * obj0 = 0 ;
5524     char *kwnames[] = {
5525         (char *) "variant", NULL
5526     };
5527
5528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Frame_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5529     if (obj0) {
5530         {
5531             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5532             if (SWIG_arg_fail(1)) SWIG_fail;
5533         }
5534     }
5535     {
5536         if (!wxPyCheckForApp()) SWIG_fail;
5537         PyThreadState* __tstate = wxPyBeginAllowThreads();
5538         result = wxFrame::GetClassDefaultAttributes((wxWindowVariant )arg1);
5539
5540         wxPyEndAllowThreads(__tstate);
5541         if (PyErr_Occurred()) SWIG_fail;
5542     }
5543     {
5544         wxVisualAttributes * resultptr;
5545         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5546         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5547     }
5548     return resultobj;
5549     fail:
5550     return NULL;
5551 }
5552
5553
5554 static PyObject * Frame_swigregister(PyObject *, PyObject *args) {
5555     PyObject *obj;
5556     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5557     SWIG_TypeClientData(SWIGTYPE_p_wxFrame, obj);
5558     Py_INCREF(obj);
5559     return Py_BuildValue((char *)"");
5560 }
5561 static PyObject *_wrap_new_Dialog(PyObject *, PyObject *args, PyObject *kwargs) {
5562     PyObject *resultobj;
5563     wxWindow *arg1 = (wxWindow *) 0 ;
5564     int arg2 = (int) (int)-1 ;
5565     wxString const &arg3_defvalue = wxPyEmptyString ;
5566     wxString *arg3 = (wxString *) &arg3_defvalue ;
5567     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5568     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5569     wxSize const &arg5_defvalue = wxDefaultSize ;
5570     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5571     long arg6 = (long) wxDEFAULT_DIALOG_STYLE ;
5572     wxString const &arg7_defvalue = wxPyDialogNameStr ;
5573     wxString *arg7 = (wxString *) &arg7_defvalue ;
5574     wxDialog *result;
5575     bool temp3 = false ;
5576     wxPoint temp4 ;
5577     wxSize temp5 ;
5578     bool temp7 = false ;
5579     PyObject * obj0 = 0 ;
5580     PyObject * obj1 = 0 ;
5581     PyObject * obj2 = 0 ;
5582     PyObject * obj3 = 0 ;
5583     PyObject * obj4 = 0 ;
5584     PyObject * obj5 = 0 ;
5585     PyObject * obj6 = 0 ;
5586     char *kwnames[] = {
5587         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5588     };
5589
5590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Dialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5591     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5592     if (SWIG_arg_fail(1)) SWIG_fail;
5593     if (obj1) {
5594         {
5595             arg2 = (int const)(SWIG_As_int(obj1));
5596             if (SWIG_arg_fail(2)) SWIG_fail;
5597         }
5598     }
5599     if (obj2) {
5600         {
5601             arg3 = wxString_in_helper(obj2);
5602             if (arg3 == NULL) SWIG_fail;
5603             temp3 = true;
5604         }
5605     }
5606     if (obj3) {
5607         {
5608             arg4 = &temp4;
5609             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5610         }
5611     }
5612     if (obj4) {
5613         {
5614             arg5 = &temp5;
5615             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5616         }
5617     }
5618     if (obj5) {
5619         {
5620             arg6 = (long)(SWIG_As_long(obj5));
5621             if (SWIG_arg_fail(6)) SWIG_fail;
5622         }
5623     }
5624     if (obj6) {
5625         {
5626             arg7 = wxString_in_helper(obj6);
5627             if (arg7 == NULL) SWIG_fail;
5628             temp7 = true;
5629         }
5630     }
5631     {
5632         if (!wxPyCheckForApp()) SWIG_fail;
5633         PyThreadState* __tstate = wxPyBeginAllowThreads();
5634         result = (wxDialog *)new wxDialog(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
5635
5636         wxPyEndAllowThreads(__tstate);
5637         if (PyErr_Occurred()) SWIG_fail;
5638     }
5639     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5640     {
5641         if (temp3)
5642         delete arg3;
5643     }
5644     {
5645         if (temp7)
5646         delete arg7;
5647     }
5648     return resultobj;
5649     fail:
5650     {
5651         if (temp3)
5652         delete arg3;
5653     }
5654     {
5655         if (temp7)
5656         delete arg7;
5657     }
5658     return NULL;
5659 }
5660
5661
5662 static PyObject *_wrap_new_PreDialog(PyObject *, PyObject *args, PyObject *kwargs) {
5663     PyObject *resultobj;
5664     wxDialog *result;
5665     char *kwnames[] = {
5666         NULL
5667     };
5668
5669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDialog",kwnames)) goto fail;
5670     {
5671         if (!wxPyCheckForApp()) SWIG_fail;
5672         PyThreadState* __tstate = wxPyBeginAllowThreads();
5673         result = (wxDialog *)new wxDialog();
5674
5675         wxPyEndAllowThreads(__tstate);
5676         if (PyErr_Occurred()) SWIG_fail;
5677     }
5678     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5679     return resultobj;
5680     fail:
5681     return NULL;
5682 }
5683
5684
5685 static PyObject *_wrap_Dialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5686     PyObject *resultobj;
5687     wxDialog *arg1 = (wxDialog *) 0 ;
5688     wxWindow *arg2 = (wxWindow *) 0 ;
5689     int arg3 = (int) (int)-1 ;
5690     wxString const &arg4_defvalue = wxPyEmptyString ;
5691     wxString *arg4 = (wxString *) &arg4_defvalue ;
5692     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5693     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5694     wxSize const &arg6_defvalue = wxDefaultSize ;
5695     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5696     long arg7 = (long) wxDEFAULT_DIALOG_STYLE ;
5697     wxString const &arg8_defvalue = wxPyDialogNameStr ;
5698     wxString *arg8 = (wxString *) &arg8_defvalue ;
5699     bool result;
5700     bool temp4 = false ;
5701     wxPoint temp5 ;
5702     wxSize temp6 ;
5703     bool temp8 = false ;
5704     PyObject * obj0 = 0 ;
5705     PyObject * obj1 = 0 ;
5706     PyObject * obj2 = 0 ;
5707     PyObject * obj3 = 0 ;
5708     PyObject * obj4 = 0 ;
5709     PyObject * obj5 = 0 ;
5710     PyObject * obj6 = 0 ;
5711     PyObject * obj7 = 0 ;
5712     char *kwnames[] = {
5713         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5714     };
5715
5716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Dialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5718     if (SWIG_arg_fail(1)) SWIG_fail;
5719     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5720     if (SWIG_arg_fail(2)) SWIG_fail;
5721     if (obj2) {
5722         {
5723             arg3 = (int const)(SWIG_As_int(obj2));
5724             if (SWIG_arg_fail(3)) SWIG_fail;
5725         }
5726     }
5727     if (obj3) {
5728         {
5729             arg4 = wxString_in_helper(obj3);
5730             if (arg4 == NULL) SWIG_fail;
5731             temp4 = true;
5732         }
5733     }
5734     if (obj4) {
5735         {
5736             arg5 = &temp5;
5737             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5738         }
5739     }
5740     if (obj5) {
5741         {
5742             arg6 = &temp6;
5743             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5744         }
5745     }
5746     if (obj6) {
5747         {
5748             arg7 = (long)(SWIG_As_long(obj6));
5749             if (SWIG_arg_fail(7)) SWIG_fail;
5750         }
5751     }
5752     if (obj7) {
5753         {
5754             arg8 = wxString_in_helper(obj7);
5755             if (arg8 == NULL) SWIG_fail;
5756             temp8 = true;
5757         }
5758     }
5759     {
5760         PyThreadState* __tstate = wxPyBeginAllowThreads();
5761         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
5762
5763         wxPyEndAllowThreads(__tstate);
5764         if (PyErr_Occurred()) SWIG_fail;
5765     }
5766     {
5767         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5768     }
5769     {
5770         if (temp4)
5771         delete arg4;
5772     }
5773     {
5774         if (temp8)
5775         delete arg8;
5776     }
5777     return resultobj;
5778     fail:
5779     {
5780         if (temp4)
5781         delete arg4;
5782     }
5783     {
5784         if (temp8)
5785         delete arg8;
5786     }
5787     return NULL;
5788 }
5789
5790
5791 static PyObject *_wrap_Dialog_SetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5792     PyObject *resultobj;
5793     wxDialog *arg1 = (wxDialog *) 0 ;
5794     int arg2 ;
5795     PyObject * obj0 = 0 ;
5796     PyObject * obj1 = 0 ;
5797     char *kwnames[] = {
5798         (char *) "self",(char *) "returnCode", NULL
5799     };
5800
5801     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_SetReturnCode",kwnames,&obj0,&obj1)) goto fail;
5802     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5803     if (SWIG_arg_fail(1)) SWIG_fail;
5804     {
5805         arg2 = (int)(SWIG_As_int(obj1));
5806         if (SWIG_arg_fail(2)) SWIG_fail;
5807     }
5808     {
5809         PyThreadState* __tstate = wxPyBeginAllowThreads();
5810         (arg1)->SetReturnCode(arg2);
5811
5812         wxPyEndAllowThreads(__tstate);
5813         if (PyErr_Occurred()) SWIG_fail;
5814     }
5815     Py_INCREF(Py_None); resultobj = Py_None;
5816     return resultobj;
5817     fail:
5818     return NULL;
5819 }
5820
5821
5822 static PyObject *_wrap_Dialog_GetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5823     PyObject *resultobj;
5824     wxDialog *arg1 = (wxDialog *) 0 ;
5825     int result;
5826     PyObject * obj0 = 0 ;
5827     char *kwnames[] = {
5828         (char *) "self", NULL
5829     };
5830
5831     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_GetReturnCode",kwnames,&obj0)) goto fail;
5832     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5833     if (SWIG_arg_fail(1)) SWIG_fail;
5834     {
5835         PyThreadState* __tstate = wxPyBeginAllowThreads();
5836         result = (int)((wxDialog const *)arg1)->GetReturnCode();
5837
5838         wxPyEndAllowThreads(__tstate);
5839         if (PyErr_Occurred()) SWIG_fail;
5840     }
5841     {
5842         resultobj = SWIG_From_int((int)(result));
5843     }
5844     return resultobj;
5845     fail:
5846     return NULL;
5847 }
5848
5849
5850 static PyObject *_wrap_Dialog_CreateTextSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5851     PyObject *resultobj;
5852     wxDialog *arg1 = (wxDialog *) 0 ;
5853     wxString *arg2 = 0 ;
5854     wxSizer *result;
5855     bool temp2 = false ;
5856     PyObject * obj0 = 0 ;
5857     PyObject * obj1 = 0 ;
5858     char *kwnames[] = {
5859         (char *) "self",(char *) "message", NULL
5860     };
5861
5862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateTextSizer",kwnames,&obj0,&obj1)) goto fail;
5863     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5864     if (SWIG_arg_fail(1)) SWIG_fail;
5865     {
5866         arg2 = wxString_in_helper(obj1);
5867         if (arg2 == NULL) SWIG_fail;
5868         temp2 = true;
5869     }
5870     {
5871         PyThreadState* __tstate = wxPyBeginAllowThreads();
5872         result = (wxSizer *)(arg1)->CreateTextSizer((wxString const &)*arg2);
5873
5874         wxPyEndAllowThreads(__tstate);
5875         if (PyErr_Occurred()) SWIG_fail;
5876     }
5877     {
5878         resultobj = wxPyMake_wxSizer(result, 0);
5879     }
5880     {
5881         if (temp2)
5882         delete arg2;
5883     }
5884     return resultobj;
5885     fail:
5886     {
5887         if (temp2)
5888         delete arg2;
5889     }
5890     return NULL;
5891 }
5892
5893
5894 static PyObject *_wrap_Dialog_CreateButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5895     PyObject *resultobj;
5896     wxDialog *arg1 = (wxDialog *) 0 ;
5897     long arg2 ;
5898     wxSizer *result;
5899     PyObject * obj0 = 0 ;
5900     PyObject * obj1 = 0 ;
5901     char *kwnames[] = {
5902         (char *) "self",(char *) "flags", NULL
5903     };
5904
5905     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateButtonSizer",kwnames,&obj0,&obj1)) goto fail;
5906     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5907     if (SWIG_arg_fail(1)) SWIG_fail;
5908     {
5909         arg2 = (long)(SWIG_As_long(obj1));
5910         if (SWIG_arg_fail(2)) SWIG_fail;
5911     }
5912     {
5913         PyThreadState* __tstate = wxPyBeginAllowThreads();
5914         result = (wxSizer *)(arg1)->CreateButtonSizer(arg2);
5915
5916         wxPyEndAllowThreads(__tstate);
5917         if (PyErr_Occurred()) SWIG_fail;
5918     }
5919     {
5920         resultobj = wxPyMake_wxSizer(result, 0);
5921     }
5922     return resultobj;
5923     fail:
5924     return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_Dialog_CreateStdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5929     PyObject *resultobj;
5930     wxDialog *arg1 = (wxDialog *) 0 ;
5931     long arg2 ;
5932     wxStdDialogButtonSizer *result;
5933     PyObject * obj0 = 0 ;
5934     PyObject * obj1 = 0 ;
5935     char *kwnames[] = {
5936         (char *) "self",(char *) "flags", NULL
5937     };
5938
5939     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateStdDialogButtonSizer",kwnames,&obj0,&obj1)) goto fail;
5940     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5941     if (SWIG_arg_fail(1)) SWIG_fail;
5942     {
5943         arg2 = (long)(SWIG_As_long(obj1));
5944         if (SWIG_arg_fail(2)) SWIG_fail;
5945     }
5946     {
5947         PyThreadState* __tstate = wxPyBeginAllowThreads();
5948         result = (wxStdDialogButtonSizer *)(arg1)->CreateStdDialogButtonSizer(arg2);
5949
5950         wxPyEndAllowThreads(__tstate);
5951         if (PyErr_Occurred()) SWIG_fail;
5952     }
5953     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 0);
5954     return resultobj;
5955     fail:
5956     return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_Dialog_IsModal(PyObject *, PyObject *args, PyObject *kwargs) {
5961     PyObject *resultobj;
5962     wxDialog *arg1 = (wxDialog *) 0 ;
5963     bool result;
5964     PyObject * obj0 = 0 ;
5965     char *kwnames[] = {
5966         (char *) "self", NULL
5967     };
5968
5969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_IsModal",kwnames,&obj0)) goto fail;
5970     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5971     if (SWIG_arg_fail(1)) SWIG_fail;
5972     {
5973         PyThreadState* __tstate = wxPyBeginAllowThreads();
5974         result = (bool)((wxDialog const *)arg1)->IsModal();
5975
5976         wxPyEndAllowThreads(__tstate);
5977         if (PyErr_Occurred()) SWIG_fail;
5978     }
5979     {
5980         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5981     }
5982     return resultobj;
5983     fail:
5984     return NULL;
5985 }
5986
5987
5988 static PyObject *_wrap_Dialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
5989     PyObject *resultobj;
5990     wxDialog *arg1 = (wxDialog *) 0 ;
5991     int result;
5992     PyObject * obj0 = 0 ;
5993     char *kwnames[] = {
5994         (char *) "self", NULL
5995     };
5996
5997     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_ShowModal",kwnames,&obj0)) goto fail;
5998     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5999     if (SWIG_arg_fail(1)) SWIG_fail;
6000     {
6001         PyThreadState* __tstate = wxPyBeginAllowThreads();
6002         result = (int)(arg1)->ShowModal();
6003
6004         wxPyEndAllowThreads(__tstate);
6005         if (PyErr_Occurred()) SWIG_fail;
6006     }
6007     {
6008         resultobj = SWIG_From_int((int)(result));
6009     }
6010     return resultobj;
6011     fail:
6012     return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_Dialog_EndModal(PyObject *, PyObject *args, PyObject *kwargs) {
6017     PyObject *resultobj;
6018     wxDialog *arg1 = (wxDialog *) 0 ;
6019     int arg2 ;
6020     PyObject * obj0 = 0 ;
6021     PyObject * obj1 = 0 ;
6022     char *kwnames[] = {
6023         (char *) "self",(char *) "retCode", NULL
6024     };
6025
6026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_EndModal",kwnames,&obj0,&obj1)) goto fail;
6027     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6028     if (SWIG_arg_fail(1)) SWIG_fail;
6029     {
6030         arg2 = (int)(SWIG_As_int(obj1));
6031         if (SWIG_arg_fail(2)) SWIG_fail;
6032     }
6033     {
6034         PyThreadState* __tstate = wxPyBeginAllowThreads();
6035         (arg1)->EndModal(arg2);
6036
6037         wxPyEndAllowThreads(__tstate);
6038         if (PyErr_Occurred()) SWIG_fail;
6039     }
6040     Py_INCREF(Py_None); resultobj = Py_None;
6041     return resultobj;
6042     fail:
6043     return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_Dialog_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6048     PyObject *resultobj;
6049     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6050     wxVisualAttributes result;
6051     PyObject * obj0 = 0 ;
6052     char *kwnames[] = {
6053         (char *) "variant", NULL
6054     };
6055
6056     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Dialog_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6057     if (obj0) {
6058         {
6059             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6060             if (SWIG_arg_fail(1)) SWIG_fail;
6061         }
6062     }
6063     {
6064         if (!wxPyCheckForApp()) SWIG_fail;
6065         PyThreadState* __tstate = wxPyBeginAllowThreads();
6066         result = wxDialog::GetClassDefaultAttributes((wxWindowVariant )arg1);
6067
6068         wxPyEndAllowThreads(__tstate);
6069         if (PyErr_Occurred()) SWIG_fail;
6070     }
6071     {
6072         wxVisualAttributes * resultptr;
6073         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6074         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6075     }
6076     return resultobj;
6077     fail:
6078     return NULL;
6079 }
6080
6081
6082 static PyObject * Dialog_swigregister(PyObject *, PyObject *args) {
6083     PyObject *obj;
6084     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6085     SWIG_TypeClientData(SWIGTYPE_p_wxDialog, obj);
6086     Py_INCREF(obj);
6087     return Py_BuildValue((char *)"");
6088 }
6089 static PyObject *_wrap_new_MiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6090     PyObject *resultobj;
6091     wxWindow *arg1 = (wxWindow *) 0 ;
6092     int arg2 = (int) (int)-1 ;
6093     wxString const &arg3_defvalue = wxPyEmptyString ;
6094     wxString *arg3 = (wxString *) &arg3_defvalue ;
6095     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6096     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6097     wxSize const &arg5_defvalue = wxDefaultSize ;
6098     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6099     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
6100     wxString const &arg7_defvalue = wxPyFrameNameStr ;
6101     wxString *arg7 = (wxString *) &arg7_defvalue ;
6102     wxMiniFrame *result;
6103     bool temp3 = false ;
6104     wxPoint temp4 ;
6105     wxSize temp5 ;
6106     bool temp7 = false ;
6107     PyObject * obj0 = 0 ;
6108     PyObject * obj1 = 0 ;
6109     PyObject * obj2 = 0 ;
6110     PyObject * obj3 = 0 ;
6111     PyObject * obj4 = 0 ;
6112     PyObject * obj5 = 0 ;
6113     PyObject * obj6 = 0 ;
6114     char *kwnames[] = {
6115         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6116     };
6117
6118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MiniFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6120     if (SWIG_arg_fail(1)) SWIG_fail;
6121     if (obj1) {
6122         {
6123             arg2 = (int const)(SWIG_As_int(obj1));
6124             if (SWIG_arg_fail(2)) SWIG_fail;
6125         }
6126     }
6127     if (obj2) {
6128         {
6129             arg3 = wxString_in_helper(obj2);
6130             if (arg3 == NULL) SWIG_fail;
6131             temp3 = true;
6132         }
6133     }
6134     if (obj3) {
6135         {
6136             arg4 = &temp4;
6137             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6138         }
6139     }
6140     if (obj4) {
6141         {
6142             arg5 = &temp5;
6143             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6144         }
6145     }
6146     if (obj5) {
6147         {
6148             arg6 = (long)(SWIG_As_long(obj5));
6149             if (SWIG_arg_fail(6)) SWIG_fail;
6150         }
6151     }
6152     if (obj6) {
6153         {
6154             arg7 = wxString_in_helper(obj6);
6155             if (arg7 == NULL) SWIG_fail;
6156             temp7 = true;
6157         }
6158     }
6159     {
6160         if (!wxPyCheckForApp()) SWIG_fail;
6161         PyThreadState* __tstate = wxPyBeginAllowThreads();
6162         result = (wxMiniFrame *)new wxMiniFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6163
6164         wxPyEndAllowThreads(__tstate);
6165         if (PyErr_Occurred()) SWIG_fail;
6166     }
6167     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6168     {
6169         if (temp3)
6170         delete arg3;
6171     }
6172     {
6173         if (temp7)
6174         delete arg7;
6175     }
6176     return resultobj;
6177     fail:
6178     {
6179         if (temp3)
6180         delete arg3;
6181     }
6182     {
6183         if (temp7)
6184         delete arg7;
6185     }
6186     return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_new_PreMiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6191     PyObject *resultobj;
6192     wxMiniFrame *result;
6193     char *kwnames[] = {
6194         NULL
6195     };
6196
6197     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMiniFrame",kwnames)) goto fail;
6198     {
6199         if (!wxPyCheckForApp()) SWIG_fail;
6200         PyThreadState* __tstate = wxPyBeginAllowThreads();
6201         result = (wxMiniFrame *)new wxMiniFrame();
6202
6203         wxPyEndAllowThreads(__tstate);
6204         if (PyErr_Occurred()) SWIG_fail;
6205     }
6206     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6207     return resultobj;
6208     fail:
6209     return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_MiniFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6214     PyObject *resultobj;
6215     wxMiniFrame *arg1 = (wxMiniFrame *) 0 ;
6216     wxWindow *arg2 = (wxWindow *) 0 ;
6217     int arg3 = (int) (int)-1 ;
6218     wxString const &arg4_defvalue = wxPyEmptyString ;
6219     wxString *arg4 = (wxString *) &arg4_defvalue ;
6220     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6221     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6222     wxSize const &arg6_defvalue = wxDefaultSize ;
6223     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6224     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
6225     wxString const &arg8_defvalue = wxPyFrameNameStr ;
6226     wxString *arg8 = (wxString *) &arg8_defvalue ;
6227     bool result;
6228     bool temp4 = false ;
6229     wxPoint temp5 ;
6230     wxSize temp6 ;
6231     bool temp8 = false ;
6232     PyObject * obj0 = 0 ;
6233     PyObject * obj1 = 0 ;
6234     PyObject * obj2 = 0 ;
6235     PyObject * obj3 = 0 ;
6236     PyObject * obj4 = 0 ;
6237     PyObject * obj5 = 0 ;
6238     PyObject * obj6 = 0 ;
6239     PyObject * obj7 = 0 ;
6240     char *kwnames[] = {
6241         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6242     };
6243
6244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MiniFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMiniFrame, SWIG_POINTER_EXCEPTION | 0);
6246     if (SWIG_arg_fail(1)) SWIG_fail;
6247     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6248     if (SWIG_arg_fail(2)) SWIG_fail;
6249     if (obj2) {
6250         {
6251             arg3 = (int const)(SWIG_As_int(obj2));
6252             if (SWIG_arg_fail(3)) SWIG_fail;
6253         }
6254     }
6255     if (obj3) {
6256         {
6257             arg4 = wxString_in_helper(obj3);
6258             if (arg4 == NULL) SWIG_fail;
6259             temp4 = true;
6260         }
6261     }
6262     if (obj4) {
6263         {
6264             arg5 = &temp5;
6265             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6266         }
6267     }
6268     if (obj5) {
6269         {
6270             arg6 = &temp6;
6271             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6272         }
6273     }
6274     if (obj6) {
6275         {
6276             arg7 = (long)(SWIG_As_long(obj6));
6277             if (SWIG_arg_fail(7)) SWIG_fail;
6278         }
6279     }
6280     if (obj7) {
6281         {
6282             arg8 = wxString_in_helper(obj7);
6283             if (arg8 == NULL) SWIG_fail;
6284             temp8 = true;
6285         }
6286     }
6287     {
6288         PyThreadState* __tstate = wxPyBeginAllowThreads();
6289         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6290
6291         wxPyEndAllowThreads(__tstate);
6292         if (PyErr_Occurred()) SWIG_fail;
6293     }
6294     {
6295         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6296     }
6297     {
6298         if (temp4)
6299         delete arg4;
6300     }
6301     {
6302         if (temp8)
6303         delete arg8;
6304     }
6305     return resultobj;
6306     fail:
6307     {
6308         if (temp4)
6309         delete arg4;
6310     }
6311     {
6312         if (temp8)
6313         delete arg8;
6314     }
6315     return NULL;
6316 }
6317
6318
6319 static PyObject * MiniFrame_swigregister(PyObject *, PyObject *args) {
6320     PyObject *obj;
6321     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6322     SWIG_TypeClientData(SWIGTYPE_p_wxMiniFrame, obj);
6323     Py_INCREF(obj);
6324     return Py_BuildValue((char *)"");
6325 }
6326 static PyObject *_wrap_new_SplashScreenWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6327     PyObject *resultobj;
6328     wxBitmap *arg1 = 0 ;
6329     wxWindow *arg2 = (wxWindow *) 0 ;
6330     int arg3 ;
6331     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6332     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6333     wxSize const &arg5_defvalue = wxDefaultSize ;
6334     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6335     long arg6 = (long) wxNO_BORDER ;
6336     wxSplashScreenWindow *result;
6337     wxPoint temp4 ;
6338     wxSize temp5 ;
6339     PyObject * obj0 = 0 ;
6340     PyObject * obj1 = 0 ;
6341     PyObject * obj2 = 0 ;
6342     PyObject * obj3 = 0 ;
6343     PyObject * obj4 = 0 ;
6344     PyObject * obj5 = 0 ;
6345     char *kwnames[] = {
6346         (char *) "bitmap",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6347     };
6348
6349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_SplashScreenWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6350     {
6351         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6352         if (SWIG_arg_fail(1)) SWIG_fail;
6353         if (arg1 == NULL) {
6354             SWIG_null_ref("wxBitmap");
6355         }
6356         if (SWIG_arg_fail(1)) SWIG_fail;
6357     }
6358     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6359     if (SWIG_arg_fail(2)) SWIG_fail;
6360     {
6361         arg3 = (int)(SWIG_As_int(obj2));
6362         if (SWIG_arg_fail(3)) SWIG_fail;
6363     }
6364     if (obj3) {
6365         {
6366             arg4 = &temp4;
6367             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6368         }
6369     }
6370     if (obj4) {
6371         {
6372             arg5 = &temp5;
6373             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6374         }
6375     }
6376     if (obj5) {
6377         {
6378             arg6 = (long)(SWIG_As_long(obj5));
6379             if (SWIG_arg_fail(6)) SWIG_fail;
6380         }
6381     }
6382     {
6383         if (!wxPyCheckForApp()) SWIG_fail;
6384         PyThreadState* __tstate = wxPyBeginAllowThreads();
6385         result = (wxSplashScreenWindow *)new wxSplashScreenWindow((wxBitmap const &)*arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
6386
6387         wxPyEndAllowThreads(__tstate);
6388         if (PyErr_Occurred()) SWIG_fail;
6389     }
6390     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 1);
6391     return resultobj;
6392     fail:
6393     return NULL;
6394 }
6395
6396
6397 static PyObject *_wrap_SplashScreenWindow_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6398     PyObject *resultobj;
6399     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6400     wxBitmap *arg2 = 0 ;
6401     PyObject * obj0 = 0 ;
6402     PyObject * obj1 = 0 ;
6403     char *kwnames[] = {
6404         (char *) "self",(char *) "bitmap", NULL
6405     };
6406
6407     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplashScreenWindow_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
6408     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6409     if (SWIG_arg_fail(1)) SWIG_fail;
6410     {
6411         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6412         if (SWIG_arg_fail(2)) SWIG_fail;
6413         if (arg2 == NULL) {
6414             SWIG_null_ref("wxBitmap");
6415         }
6416         if (SWIG_arg_fail(2)) SWIG_fail;
6417     }
6418     {
6419         PyThreadState* __tstate = wxPyBeginAllowThreads();
6420         (arg1)->SetBitmap((wxBitmap const &)*arg2);
6421
6422         wxPyEndAllowThreads(__tstate);
6423         if (PyErr_Occurred()) SWIG_fail;
6424     }
6425     Py_INCREF(Py_None); resultobj = Py_None;
6426     return resultobj;
6427     fail:
6428     return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_SplashScreenWindow_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6433     PyObject *resultobj;
6434     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6435     wxBitmap *result;
6436     PyObject * obj0 = 0 ;
6437     char *kwnames[] = {
6438         (char *) "self", NULL
6439     };
6440
6441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreenWindow_GetBitmap",kwnames,&obj0)) goto fail;
6442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6443     if (SWIG_arg_fail(1)) SWIG_fail;
6444     {
6445         PyThreadState* __tstate = wxPyBeginAllowThreads();
6446         {
6447             wxBitmap &_result_ref = (arg1)->GetBitmap();
6448             result = (wxBitmap *) &_result_ref;
6449         }
6450
6451         wxPyEndAllowThreads(__tstate);
6452         if (PyErr_Occurred()) SWIG_fail;
6453     }
6454     {
6455         wxBitmap* resultptr = new wxBitmap(*result);
6456         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
6457     }
6458     return resultobj;
6459     fail:
6460     return NULL;
6461 }
6462
6463
6464 static PyObject * SplashScreenWindow_swigregister(PyObject *, PyObject *args) {
6465     PyObject *obj;
6466     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6467     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreenWindow, obj);
6468     Py_INCREF(obj);
6469     return Py_BuildValue((char *)"");
6470 }
6471 static PyObject *_wrap_new_SplashScreen(PyObject *, PyObject *args, PyObject *kwargs) {
6472     PyObject *resultobj;
6473     wxBitmap *arg1 = 0 ;
6474     long arg2 ;
6475     int arg3 ;
6476     wxWindow *arg4 = (wxWindow *) 0 ;
6477     int arg5 = (int) -1 ;
6478     wxPoint const &arg6_defvalue = wxDefaultPosition ;
6479     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
6480     wxSize const &arg7_defvalue = wxDefaultSize ;
6481     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
6482     long arg8 = (long) wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP ;
6483     wxSplashScreen *result;
6484     wxPoint temp6 ;
6485     wxSize temp7 ;
6486     PyObject * obj0 = 0 ;
6487     PyObject * obj1 = 0 ;
6488     PyObject * obj2 = 0 ;
6489     PyObject * obj3 = 0 ;
6490     PyObject * obj4 = 0 ;
6491     PyObject * obj5 = 0 ;
6492     PyObject * obj6 = 0 ;
6493     PyObject * obj7 = 0 ;
6494     char *kwnames[] = {
6495         (char *) "bitmap",(char *) "splashStyle",(char *) "milliseconds",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6496     };
6497
6498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:new_SplashScreen",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6499     {
6500         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6501         if (SWIG_arg_fail(1)) SWIG_fail;
6502         if (arg1 == NULL) {
6503             SWIG_null_ref("wxBitmap");
6504         }
6505         if (SWIG_arg_fail(1)) SWIG_fail;
6506     }
6507     {
6508         arg2 = (long)(SWIG_As_long(obj1));
6509         if (SWIG_arg_fail(2)) SWIG_fail;
6510     }
6511     {
6512         arg3 = (int)(SWIG_As_int(obj2));
6513         if (SWIG_arg_fail(3)) SWIG_fail;
6514     }
6515     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6516     if (SWIG_arg_fail(4)) SWIG_fail;
6517     if (obj4) {
6518         {
6519             arg5 = (int)(SWIG_As_int(obj4));
6520             if (SWIG_arg_fail(5)) SWIG_fail;
6521         }
6522     }
6523     if (obj5) {
6524         {
6525             arg6 = &temp6;
6526             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
6527         }
6528     }
6529     if (obj6) {
6530         {
6531             arg7 = &temp7;
6532             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
6533         }
6534     }
6535     if (obj7) {
6536         {
6537             arg8 = (long)(SWIG_As_long(obj7));
6538             if (SWIG_arg_fail(8)) SWIG_fail;
6539         }
6540     }
6541     {
6542         if (!wxPyCheckForApp()) SWIG_fail;
6543         PyThreadState* __tstate = wxPyBeginAllowThreads();
6544         result = (wxSplashScreen *)new wxSplashScreen((wxBitmap const &)*arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8);
6545
6546         wxPyEndAllowThreads(__tstate);
6547         if (PyErr_Occurred()) SWIG_fail;
6548     }
6549     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreen, 1);
6550     return resultobj;
6551     fail:
6552     return NULL;
6553 }
6554
6555
6556 static PyObject *_wrap_SplashScreen_GetSplashStyle(PyObject *, PyObject *args, PyObject *kwargs) {
6557     PyObject *resultobj;
6558     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6559     long result;
6560     PyObject * obj0 = 0 ;
6561     char *kwnames[] = {
6562         (char *) "self", NULL
6563     };
6564
6565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashStyle",kwnames,&obj0)) goto fail;
6566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6567     if (SWIG_arg_fail(1)) SWIG_fail;
6568     {
6569         PyThreadState* __tstate = wxPyBeginAllowThreads();
6570         result = (long)((wxSplashScreen const *)arg1)->GetSplashStyle();
6571
6572         wxPyEndAllowThreads(__tstate);
6573         if (PyErr_Occurred()) SWIG_fail;
6574     }
6575     {
6576         resultobj = SWIG_From_long((long)(result));
6577     }
6578     return resultobj;
6579     fail:
6580     return NULL;
6581 }
6582
6583
6584 static PyObject *_wrap_SplashScreen_GetSplashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6585     PyObject *resultobj;
6586     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6587     wxSplashScreenWindow *result;
6588     PyObject * obj0 = 0 ;
6589     char *kwnames[] = {
6590         (char *) "self", NULL
6591     };
6592
6593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashWindow",kwnames,&obj0)) goto fail;
6594     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6595     if (SWIG_arg_fail(1)) SWIG_fail;
6596     {
6597         PyThreadState* __tstate = wxPyBeginAllowThreads();
6598         result = (wxSplashScreenWindow *)((wxSplashScreen const *)arg1)->GetSplashWindow();
6599
6600         wxPyEndAllowThreads(__tstate);
6601         if (PyErr_Occurred()) SWIG_fail;
6602     }
6603     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 0);
6604     return resultobj;
6605     fail:
6606     return NULL;
6607 }
6608
6609
6610 static PyObject *_wrap_SplashScreen_GetTimeout(PyObject *, PyObject *args, PyObject *kwargs) {
6611     PyObject *resultobj;
6612     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6613     int result;
6614     PyObject * obj0 = 0 ;
6615     char *kwnames[] = {
6616         (char *) "self", NULL
6617     };
6618
6619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetTimeout",kwnames,&obj0)) goto fail;
6620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6621     if (SWIG_arg_fail(1)) SWIG_fail;
6622     {
6623         PyThreadState* __tstate = wxPyBeginAllowThreads();
6624         result = (int)((wxSplashScreen const *)arg1)->GetTimeout();
6625
6626         wxPyEndAllowThreads(__tstate);
6627         if (PyErr_Occurred()) SWIG_fail;
6628     }
6629     {
6630         resultobj = SWIG_From_int((int)(result));
6631     }
6632     return resultobj;
6633     fail:
6634     return NULL;
6635 }
6636
6637
6638 static PyObject * SplashScreen_swigregister(PyObject *, PyObject *args) {
6639     PyObject *obj;
6640     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6641     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreen, obj);
6642     Py_INCREF(obj);
6643     return Py_BuildValue((char *)"");
6644 }
6645 static PyObject *_wrap_new_StatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6646     PyObject *resultobj;
6647     wxWindow *arg1 = (wxWindow *) 0 ;
6648     int arg2 = (int) -1 ;
6649     long arg3 = (long) wxST_SIZEGRIP|wxFULL_REPAINT_ON_RESIZE ;
6650     wxString const &arg4_defvalue = wxPyStatusLineNameStr ;
6651     wxString *arg4 = (wxString *) &arg4_defvalue ;
6652     wxStatusBar *result;
6653     bool temp4 = false ;
6654     PyObject * obj0 = 0 ;
6655     PyObject * obj1 = 0 ;
6656     PyObject * obj2 = 0 ;
6657     PyObject * obj3 = 0 ;
6658     char *kwnames[] = {
6659         (char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6660     };
6661
6662     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_StatusBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6663     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6664     if (SWIG_arg_fail(1)) SWIG_fail;
6665     if (obj1) {
6666         {
6667             arg2 = (int)(SWIG_As_int(obj1));
6668             if (SWIG_arg_fail(2)) SWIG_fail;
6669         }
6670     }
6671     if (obj2) {
6672         {
6673             arg3 = (long)(SWIG_As_long(obj2));
6674             if (SWIG_arg_fail(3)) SWIG_fail;
6675         }
6676     }
6677     if (obj3) {
6678         {
6679             arg4 = wxString_in_helper(obj3);
6680             if (arg4 == NULL) SWIG_fail;
6681             temp4 = true;
6682         }
6683     }
6684     {
6685         if (!wxPyCheckForApp()) SWIG_fail;
6686         PyThreadState* __tstate = wxPyBeginAllowThreads();
6687         result = (wxStatusBar *)new wxStatusBar(arg1,arg2,arg3,(wxString const &)*arg4);
6688
6689         wxPyEndAllowThreads(__tstate);
6690         if (PyErr_Occurred()) SWIG_fail;
6691     }
6692     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6693     {
6694         if (temp4)
6695         delete arg4;
6696     }
6697     return resultobj;
6698     fail:
6699     {
6700         if (temp4)
6701         delete arg4;
6702     }
6703     return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_new_PreStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6708     PyObject *resultobj;
6709     wxStatusBar *result;
6710     char *kwnames[] = {
6711         NULL
6712     };
6713
6714     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStatusBar",kwnames)) goto fail;
6715     {
6716         if (!wxPyCheckForApp()) SWIG_fail;
6717         PyThreadState* __tstate = wxPyBeginAllowThreads();
6718         result = (wxStatusBar *)new wxStatusBar();
6719
6720         wxPyEndAllowThreads(__tstate);
6721         if (PyErr_Occurred()) SWIG_fail;
6722     }
6723     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6724     return resultobj;
6725     fail:
6726     return NULL;
6727 }
6728
6729
6730 static PyObject *_wrap_StatusBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6731     PyObject *resultobj;
6732     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6733     wxWindow *arg2 = (wxWindow *) 0 ;
6734     int arg3 = (int) -1 ;
6735     long arg4 = (long) wxST_SIZEGRIP ;
6736     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
6737     wxString *arg5 = (wxString *) &arg5_defvalue ;
6738     bool result;
6739     bool temp5 = false ;
6740     PyObject * obj0 = 0 ;
6741     PyObject * obj1 = 0 ;
6742     PyObject * obj2 = 0 ;
6743     PyObject * obj3 = 0 ;
6744     PyObject * obj4 = 0 ;
6745     char *kwnames[] = {
6746         (char *) "self",(char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6747     };
6748
6749     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:StatusBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6750     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6751     if (SWIG_arg_fail(1)) SWIG_fail;
6752     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6753     if (SWIG_arg_fail(2)) SWIG_fail;
6754     if (obj2) {
6755         {
6756             arg3 = (int)(SWIG_As_int(obj2));
6757             if (SWIG_arg_fail(3)) SWIG_fail;
6758         }
6759     }
6760     if (obj3) {
6761         {
6762             arg4 = (long)(SWIG_As_long(obj3));
6763             if (SWIG_arg_fail(4)) SWIG_fail;
6764         }
6765     }
6766     if (obj4) {
6767         {
6768             arg5 = wxString_in_helper(obj4);
6769             if (arg5 == NULL) SWIG_fail;
6770             temp5 = true;
6771         }
6772     }
6773     {
6774         PyThreadState* __tstate = wxPyBeginAllowThreads();
6775         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxString const &)*arg5);
6776
6777         wxPyEndAllowThreads(__tstate);
6778         if (PyErr_Occurred()) SWIG_fail;
6779     }
6780     {
6781         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6782     }
6783     {
6784         if (temp5)
6785         delete arg5;
6786     }
6787     return resultobj;
6788     fail:
6789     {
6790         if (temp5)
6791         delete arg5;
6792     }
6793     return NULL;
6794 }
6795
6796
6797 static PyObject *_wrap_StatusBar_SetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6798     PyObject *resultobj;
6799     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6800     int arg2 = (int) 1 ;
6801     PyObject * obj0 = 0 ;
6802     PyObject * obj1 = 0 ;
6803     char *kwnames[] = {
6804         (char *) "self",(char *) "number", NULL
6805     };
6806
6807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_SetFieldsCount",kwnames,&obj0,&obj1)) goto fail;
6808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6809     if (SWIG_arg_fail(1)) SWIG_fail;
6810     if (obj1) {
6811         {
6812             arg2 = (int)(SWIG_As_int(obj1));
6813             if (SWIG_arg_fail(2)) SWIG_fail;
6814         }
6815     }
6816     {
6817         PyThreadState* __tstate = wxPyBeginAllowThreads();
6818         (arg1)->SetFieldsCount(arg2);
6819
6820         wxPyEndAllowThreads(__tstate);
6821         if (PyErr_Occurred()) SWIG_fail;
6822     }
6823     Py_INCREF(Py_None); resultobj = Py_None;
6824     return resultobj;
6825     fail:
6826     return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_StatusBar_GetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6831     PyObject *resultobj;
6832     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6833     int result;
6834     PyObject * obj0 = 0 ;
6835     char *kwnames[] = {
6836         (char *) "self", NULL
6837     };
6838
6839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetFieldsCount",kwnames,&obj0)) goto fail;
6840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6841     if (SWIG_arg_fail(1)) SWIG_fail;
6842     {
6843         PyThreadState* __tstate = wxPyBeginAllowThreads();
6844         result = (int)((wxStatusBar const *)arg1)->GetFieldsCount();
6845
6846         wxPyEndAllowThreads(__tstate);
6847         if (PyErr_Occurred()) SWIG_fail;
6848     }
6849     {
6850         resultobj = SWIG_From_int((int)(result));
6851     }
6852     return resultobj;
6853     fail:
6854     return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_StatusBar_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6859     PyObject *resultobj;
6860     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6861     wxString *arg2 = 0 ;
6862     int arg3 = (int) 0 ;
6863     bool temp2 = false ;
6864     PyObject * obj0 = 0 ;
6865     PyObject * obj1 = 0 ;
6866     PyObject * obj2 = 0 ;
6867     char *kwnames[] = {
6868         (char *) "self",(char *) "text",(char *) "number", NULL
6869     };
6870
6871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
6872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6873     if (SWIG_arg_fail(1)) SWIG_fail;
6874     {
6875         arg2 = wxString_in_helper(obj1);
6876         if (arg2 == NULL) SWIG_fail;
6877         temp2 = true;
6878     }
6879     if (obj2) {
6880         {
6881             arg3 = (int)(SWIG_As_int(obj2));
6882             if (SWIG_arg_fail(3)) SWIG_fail;
6883         }
6884     }
6885     {
6886         PyThreadState* __tstate = wxPyBeginAllowThreads();
6887         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
6888
6889         wxPyEndAllowThreads(__tstate);
6890         if (PyErr_Occurred()) SWIG_fail;
6891     }
6892     Py_INCREF(Py_None); resultobj = Py_None;
6893     {
6894         if (temp2)
6895         delete arg2;
6896     }
6897     return resultobj;
6898     fail:
6899     {
6900         if (temp2)
6901         delete arg2;
6902     }
6903     return NULL;
6904 }
6905
6906
6907 static PyObject *_wrap_StatusBar_GetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6908     PyObject *resultobj;
6909     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6910     int arg2 = (int) 0 ;
6911     wxString result;
6912     PyObject * obj0 = 0 ;
6913     PyObject * obj1 = 0 ;
6914     char *kwnames[] = {
6915         (char *) "self",(char *) "number", NULL
6916     };
6917
6918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_GetStatusText",kwnames,&obj0,&obj1)) goto fail;
6919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6920     if (SWIG_arg_fail(1)) SWIG_fail;
6921     if (obj1) {
6922         {
6923             arg2 = (int)(SWIG_As_int(obj1));
6924             if (SWIG_arg_fail(2)) SWIG_fail;
6925         }
6926     }
6927     {
6928         PyThreadState* __tstate = wxPyBeginAllowThreads();
6929         result = ((wxStatusBar const *)arg1)->GetStatusText(arg2);
6930
6931         wxPyEndAllowThreads(__tstate);
6932         if (PyErr_Occurred()) SWIG_fail;
6933     }
6934     {
6935 #if wxUSE_UNICODE
6936         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6937 #else
6938         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6939 #endif
6940     }
6941     return resultobj;
6942     fail:
6943     return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_StatusBar_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6948     PyObject *resultobj;
6949     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6950     wxString *arg2 = 0 ;
6951     int arg3 = (int) 0 ;
6952     bool temp2 = false ;
6953     PyObject * obj0 = 0 ;
6954     PyObject * obj1 = 0 ;
6955     PyObject * obj2 = 0 ;
6956     char *kwnames[] = {
6957         (char *) "self",(char *) "text",(char *) "number", NULL
6958     };
6959
6960     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
6961     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6962     if (SWIG_arg_fail(1)) SWIG_fail;
6963     {
6964         arg2 = wxString_in_helper(obj1);
6965         if (arg2 == NULL) SWIG_fail;
6966         temp2 = true;
6967     }
6968     if (obj2) {
6969         {
6970             arg3 = (int)(SWIG_As_int(obj2));
6971             if (SWIG_arg_fail(3)) SWIG_fail;
6972         }
6973     }
6974     {
6975         PyThreadState* __tstate = wxPyBeginAllowThreads();
6976         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
6977
6978         wxPyEndAllowThreads(__tstate);
6979         if (PyErr_Occurred()) SWIG_fail;
6980     }
6981     Py_INCREF(Py_None); resultobj = Py_None;
6982     {
6983         if (temp2)
6984         delete arg2;
6985     }
6986     return resultobj;
6987     fail:
6988     {
6989         if (temp2)
6990         delete arg2;
6991     }
6992     return NULL;
6993 }
6994
6995
6996 static PyObject *_wrap_StatusBar_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6997     PyObject *resultobj;
6998     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6999     int arg2 = (int) 0 ;
7000     PyObject * obj0 = 0 ;
7001     PyObject * obj1 = 0 ;
7002     char *kwnames[] = {
7003         (char *) "self",(char *) "number", NULL
7004     };
7005
7006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
7007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7008     if (SWIG_arg_fail(1)) SWIG_fail;
7009     if (obj1) {
7010         {
7011             arg2 = (int)(SWIG_As_int(obj1));
7012             if (SWIG_arg_fail(2)) SWIG_fail;
7013         }
7014     }
7015     {
7016         PyThreadState* __tstate = wxPyBeginAllowThreads();
7017         (arg1)->PopStatusText(arg2);
7018
7019         wxPyEndAllowThreads(__tstate);
7020         if (PyErr_Occurred()) SWIG_fail;
7021     }
7022     Py_INCREF(Py_None); resultobj = Py_None;
7023     return resultobj;
7024     fail:
7025     return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_StatusBar_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
7030     PyObject *resultobj;
7031     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7032     int arg2 ;
7033     int *arg3 = (int *) 0 ;
7034     PyObject * obj0 = 0 ;
7035     PyObject * obj1 = 0 ;
7036     char *kwnames[] = {
7037         (char *) "self",(char *) "widths", NULL
7038     };
7039
7040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
7041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7042     if (SWIG_arg_fail(1)) SWIG_fail;
7043     {
7044         arg2 = PyList_Size(obj1);
7045         arg3 =  int_LIST_helper(obj1);
7046         if (arg3 == NULL) SWIG_fail;
7047     }
7048     {
7049         PyThreadState* __tstate = wxPyBeginAllowThreads();
7050         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
7051
7052         wxPyEndAllowThreads(__tstate);
7053         if (PyErr_Occurred()) SWIG_fail;
7054     }
7055     Py_INCREF(Py_None); resultobj = Py_None;
7056     {
7057         if (arg3) delete [] arg3;
7058     }
7059     return resultobj;
7060     fail:
7061     {
7062         if (arg3) delete [] arg3;
7063     }
7064     return NULL;
7065 }
7066
7067
7068 static PyObject *_wrap_StatusBar_SetStatusStyles(PyObject *, PyObject *args, PyObject *kwargs) {
7069     PyObject *resultobj;
7070     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7071     int arg2 ;
7072     int *arg3 = (int *) 0 ;
7073     PyObject * obj0 = 0 ;
7074     PyObject * obj1 = 0 ;
7075     char *kwnames[] = {
7076         (char *) "self",(char *) "styles", NULL
7077     };
7078
7079     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusStyles",kwnames,&obj0,&obj1)) goto fail;
7080     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7081     if (SWIG_arg_fail(1)) SWIG_fail;
7082     {
7083         arg2 = PyList_Size(obj1);
7084         arg3 =  int_LIST_helper(obj1);
7085         if (arg3 == NULL) SWIG_fail;
7086     }
7087     {
7088         PyThreadState* __tstate = wxPyBeginAllowThreads();
7089         (arg1)->SetStatusStyles(arg2,(int const *)arg3);
7090
7091         wxPyEndAllowThreads(__tstate);
7092         if (PyErr_Occurred()) SWIG_fail;
7093     }
7094     Py_INCREF(Py_None); resultobj = Py_None;
7095     {
7096         if (arg3) delete [] arg3;
7097     }
7098     return resultobj;
7099     fail:
7100     {
7101         if (arg3) delete [] arg3;
7102     }
7103     return NULL;
7104 }
7105
7106
7107 static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *, PyObject *args, PyObject *kwargs) {
7108     PyObject *resultobj;
7109     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7110     int arg2 ;
7111     wxRect result;
7112     PyObject * obj0 = 0 ;
7113     PyObject * obj1 = 0 ;
7114     char *kwnames[] = {
7115         (char *) "self",(char *) "i", NULL
7116     };
7117
7118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_GetFieldRect",kwnames,&obj0,&obj1)) goto fail;
7119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7120     if (SWIG_arg_fail(1)) SWIG_fail;
7121     {
7122         arg2 = (int)(SWIG_As_int(obj1));
7123         if (SWIG_arg_fail(2)) SWIG_fail;
7124     }
7125     {
7126         PyThreadState* __tstate = wxPyBeginAllowThreads();
7127         result = wxStatusBar_GetFieldRect(arg1,arg2);
7128
7129         wxPyEndAllowThreads(__tstate);
7130         if (PyErr_Occurred()) SWIG_fail;
7131     }
7132     {
7133         wxRect * resultptr;
7134         resultptr = new wxRect((wxRect &)(result));
7135         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7136     }
7137     return resultobj;
7138     fail:
7139     return NULL;
7140 }
7141
7142
7143 static PyObject *_wrap_StatusBar_SetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7144     PyObject *resultobj;
7145     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7146     int arg2 ;
7147     PyObject * obj0 = 0 ;
7148     PyObject * obj1 = 0 ;
7149     char *kwnames[] = {
7150         (char *) "self",(char *) "height", NULL
7151     };
7152
7153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetMinHeight",kwnames,&obj0,&obj1)) goto fail;
7154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7155     if (SWIG_arg_fail(1)) SWIG_fail;
7156     {
7157         arg2 = (int)(SWIG_As_int(obj1));
7158         if (SWIG_arg_fail(2)) SWIG_fail;
7159     }
7160     {
7161         PyThreadState* __tstate = wxPyBeginAllowThreads();
7162         (arg1)->SetMinHeight(arg2);
7163
7164         wxPyEndAllowThreads(__tstate);
7165         if (PyErr_Occurred()) SWIG_fail;
7166     }
7167     Py_INCREF(Py_None); resultobj = Py_None;
7168     return resultobj;
7169     fail:
7170     return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_StatusBar_GetBorderX(PyObject *, PyObject *args, PyObject *kwargs) {
7175     PyObject *resultobj;
7176     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7177     int result;
7178     PyObject * obj0 = 0 ;
7179     char *kwnames[] = {
7180         (char *) "self", NULL
7181     };
7182
7183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderX",kwnames,&obj0)) goto fail;
7184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7185     if (SWIG_arg_fail(1)) SWIG_fail;
7186     {
7187         PyThreadState* __tstate = wxPyBeginAllowThreads();
7188         result = (int)((wxStatusBar const *)arg1)->GetBorderX();
7189
7190         wxPyEndAllowThreads(__tstate);
7191         if (PyErr_Occurred()) SWIG_fail;
7192     }
7193     {
7194         resultobj = SWIG_From_int((int)(result));
7195     }
7196     return resultobj;
7197     fail:
7198     return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_StatusBar_GetBorderY(PyObject *, PyObject *args, PyObject *kwargs) {
7203     PyObject *resultobj;
7204     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7205     int result;
7206     PyObject * obj0 = 0 ;
7207     char *kwnames[] = {
7208         (char *) "self", NULL
7209     };
7210
7211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderY",kwnames,&obj0)) goto fail;
7212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7213     if (SWIG_arg_fail(1)) SWIG_fail;
7214     {
7215         PyThreadState* __tstate = wxPyBeginAllowThreads();
7216         result = (int)((wxStatusBar const *)arg1)->GetBorderY();
7217
7218         wxPyEndAllowThreads(__tstate);
7219         if (PyErr_Occurred()) SWIG_fail;
7220     }
7221     {
7222         resultobj = SWIG_From_int((int)(result));
7223     }
7224     return resultobj;
7225     fail:
7226     return NULL;
7227 }
7228
7229
7230 static PyObject *_wrap_StatusBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7231     PyObject *resultobj;
7232     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7233     wxVisualAttributes result;
7234     PyObject * obj0 = 0 ;
7235     char *kwnames[] = {
7236         (char *) "variant", NULL
7237     };
7238
7239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StatusBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7240     if (obj0) {
7241         {
7242             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7243             if (SWIG_arg_fail(1)) SWIG_fail;
7244         }
7245     }
7246     {
7247         if (!wxPyCheckForApp()) SWIG_fail;
7248         PyThreadState* __tstate = wxPyBeginAllowThreads();
7249         result = wxStatusBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
7250
7251         wxPyEndAllowThreads(__tstate);
7252         if (PyErr_Occurred()) SWIG_fail;
7253     }
7254     {
7255         wxVisualAttributes * resultptr;
7256         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7257         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7258     }
7259     return resultobj;
7260     fail:
7261     return NULL;
7262 }
7263
7264
7265 static PyObject * StatusBar_swigregister(PyObject *, PyObject *args) {
7266     PyObject *obj;
7267     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7268     SWIG_TypeClientData(SWIGTYPE_p_wxStatusBar, obj);
7269     Py_INCREF(obj);
7270     return Py_BuildValue((char *)"");
7271 }
7272 static int _wrap_SplitterNameStr_set(PyObject *) {
7273     PyErr_SetString(PyExc_TypeError,"Variable SplitterNameStr is read-only.");
7274     return 1;
7275 }
7276
7277
7278 static PyObject *_wrap_SplitterNameStr_get(void) {
7279     PyObject *pyobj;
7280
7281     {
7282 #if wxUSE_UNICODE
7283         pyobj = PyUnicode_FromWideChar((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7284 #else
7285         pyobj = PyString_FromStringAndSize((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7286 #endif
7287     }
7288     return pyobj;
7289 }
7290
7291
7292 static PyObject *_wrap_new_SplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7293     PyObject *resultobj;
7294     wxWindow *arg1 = (wxWindow *) 0 ;
7295     int arg2 = (int) -1 ;
7296     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7297     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7298     wxSize const &arg4_defvalue = wxDefaultSize ;
7299     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7300     long arg5 = (long) wxSP_3D ;
7301     wxString const &arg6_defvalue = wxPySplitterNameStr ;
7302     wxString *arg6 = (wxString *) &arg6_defvalue ;
7303     wxSplitterWindow *result;
7304     wxPoint temp3 ;
7305     wxSize temp4 ;
7306     bool temp6 = false ;
7307     PyObject * obj0 = 0 ;
7308     PyObject * obj1 = 0 ;
7309     PyObject * obj2 = 0 ;
7310     PyObject * obj3 = 0 ;
7311     PyObject * obj4 = 0 ;
7312     PyObject * obj5 = 0 ;
7313     char *kwnames[] = {
7314         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7315     };
7316
7317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SplitterWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
7318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7319     if (SWIG_arg_fail(1)) SWIG_fail;
7320     if (obj1) {
7321         {
7322             arg2 = (int)(SWIG_As_int(obj1));
7323             if (SWIG_arg_fail(2)) SWIG_fail;
7324         }
7325     }
7326     if (obj2) {
7327         {
7328             arg3 = &temp3;
7329             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7330         }
7331     }
7332     if (obj3) {
7333         {
7334             arg4 = &temp4;
7335             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7336         }
7337     }
7338     if (obj4) {
7339         {
7340             arg5 = (long)(SWIG_As_long(obj4));
7341             if (SWIG_arg_fail(5)) SWIG_fail;
7342         }
7343     }
7344     if (obj5) {
7345         {
7346             arg6 = wxString_in_helper(obj5);
7347             if (arg6 == NULL) SWIG_fail;
7348             temp6 = true;
7349         }
7350     }
7351     {
7352         if (!wxPyCheckForApp()) SWIG_fail;
7353         PyThreadState* __tstate = wxPyBeginAllowThreads();
7354         result = (wxSplitterWindow *)new wxSplitterWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
7355
7356         wxPyEndAllowThreads(__tstate);
7357         if (PyErr_Occurred()) SWIG_fail;
7358     }
7359     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7360     {
7361         if (temp6)
7362         delete arg6;
7363     }
7364     return resultobj;
7365     fail:
7366     {
7367         if (temp6)
7368         delete arg6;
7369     }
7370     return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_new_PreSplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7375     PyObject *resultobj;
7376     wxSplitterWindow *result;
7377     char *kwnames[] = {
7378         NULL
7379     };
7380
7381     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSplitterWindow",kwnames)) goto fail;
7382     {
7383         if (!wxPyCheckForApp()) SWIG_fail;
7384         PyThreadState* __tstate = wxPyBeginAllowThreads();
7385         result = (wxSplitterWindow *)new wxSplitterWindow();
7386
7387         wxPyEndAllowThreads(__tstate);
7388         if (PyErr_Occurred()) SWIG_fail;
7389     }
7390     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7391     return resultobj;
7392     fail:
7393     return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_SplitterWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7398     PyObject *resultobj;
7399     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7400     wxWindow *arg2 = (wxWindow *) 0 ;
7401     int arg3 = (int) -1 ;
7402     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7403     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7404     wxSize const &arg5_defvalue = wxDefaultSize ;
7405     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7406     long arg6 = (long) wxSP_3D ;
7407     wxString const &arg7_defvalue = wxPySplitterNameStr ;
7408     wxString *arg7 = (wxString *) &arg7_defvalue ;
7409     bool result;
7410     wxPoint temp4 ;
7411     wxSize temp5 ;
7412     bool temp7 = false ;
7413     PyObject * obj0 = 0 ;
7414     PyObject * obj1 = 0 ;
7415     PyObject * obj2 = 0 ;
7416     PyObject * obj3 = 0 ;
7417     PyObject * obj4 = 0 ;
7418     PyObject * obj5 = 0 ;
7419     PyObject * obj6 = 0 ;
7420     char *kwnames[] = {
7421         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7422     };
7423
7424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SplitterWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
7425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7426     if (SWIG_arg_fail(1)) SWIG_fail;
7427     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7428     if (SWIG_arg_fail(2)) SWIG_fail;
7429     if (obj2) {
7430         {
7431             arg3 = (int)(SWIG_As_int(obj2));
7432             if (SWIG_arg_fail(3)) SWIG_fail;
7433         }
7434     }
7435     if (obj3) {
7436         {
7437             arg4 = &temp4;
7438             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7439         }
7440     }
7441     if (obj4) {
7442         {
7443             arg5 = &temp5;
7444             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7445         }
7446     }
7447     if (obj5) {
7448         {
7449             arg6 = (long)(SWIG_As_long(obj5));
7450             if (SWIG_arg_fail(6)) SWIG_fail;
7451         }
7452     }
7453     if (obj6) {
7454         {
7455             arg7 = wxString_in_helper(obj6);
7456             if (arg7 == NULL) SWIG_fail;
7457             temp7 = true;
7458         }
7459     }
7460     {
7461         PyThreadState* __tstate = wxPyBeginAllowThreads();
7462         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
7463
7464         wxPyEndAllowThreads(__tstate);
7465         if (PyErr_Occurred()) SWIG_fail;
7466     }
7467     {
7468         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7469     }
7470     {
7471         if (temp7)
7472         delete arg7;
7473     }
7474     return resultobj;
7475     fail:
7476     {
7477         if (temp7)
7478         delete arg7;
7479     }
7480     return NULL;
7481 }
7482
7483
7484 static PyObject *_wrap_SplitterWindow_GetWindow1(PyObject *, PyObject *args, PyObject *kwargs) {
7485     PyObject *resultobj;
7486     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7487     wxWindow *result;
7488     PyObject * obj0 = 0 ;
7489     char *kwnames[] = {
7490         (char *) "self", NULL
7491     };
7492
7493     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow1",kwnames,&obj0)) goto fail;
7494     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7495     if (SWIG_arg_fail(1)) SWIG_fail;
7496     {
7497         PyThreadState* __tstate = wxPyBeginAllowThreads();
7498         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow1();
7499
7500         wxPyEndAllowThreads(__tstate);
7501         if (PyErr_Occurred()) SWIG_fail;
7502     }
7503     {
7504         resultobj = wxPyMake_wxObject(result, 0);
7505     }
7506     return resultobj;
7507     fail:
7508     return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_SplitterWindow_GetWindow2(PyObject *, PyObject *args, PyObject *kwargs) {
7513     PyObject *resultobj;
7514     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7515     wxWindow *result;
7516     PyObject * obj0 = 0 ;
7517     char *kwnames[] = {
7518         (char *) "self", NULL
7519     };
7520
7521     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow2",kwnames,&obj0)) goto fail;
7522     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7523     if (SWIG_arg_fail(1)) SWIG_fail;
7524     {
7525         PyThreadState* __tstate = wxPyBeginAllowThreads();
7526         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow2();
7527
7528         wxPyEndAllowThreads(__tstate);
7529         if (PyErr_Occurred()) SWIG_fail;
7530     }
7531     {
7532         resultobj = wxPyMake_wxObject(result, 0);
7533     }
7534     return resultobj;
7535     fail:
7536     return NULL;
7537 }
7538
7539
7540 static PyObject *_wrap_SplitterWindow_SetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7541     PyObject *resultobj;
7542     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7543     int arg2 ;
7544     PyObject * obj0 = 0 ;
7545     PyObject * obj1 = 0 ;
7546     char *kwnames[] = {
7547         (char *) "self",(char *) "mode", NULL
7548     };
7549
7550     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSplitMode",kwnames,&obj0,&obj1)) goto fail;
7551     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7552     if (SWIG_arg_fail(1)) SWIG_fail;
7553     {
7554         arg2 = (int)(SWIG_As_int(obj1));
7555         if (SWIG_arg_fail(2)) SWIG_fail;
7556     }
7557     {
7558         PyThreadState* __tstate = wxPyBeginAllowThreads();
7559         (arg1)->SetSplitMode(arg2);
7560
7561         wxPyEndAllowThreads(__tstate);
7562         if (PyErr_Occurred()) SWIG_fail;
7563     }
7564     Py_INCREF(Py_None); resultobj = Py_None;
7565     return resultobj;
7566     fail:
7567     return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_SplitterWindow_GetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7572     PyObject *resultobj;
7573     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7574     wxSplitMode result;
7575     PyObject * obj0 = 0 ;
7576     char *kwnames[] = {
7577         (char *) "self", NULL
7578     };
7579
7580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSplitMode",kwnames,&obj0)) goto fail;
7581     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7582     if (SWIG_arg_fail(1)) SWIG_fail;
7583     {
7584         PyThreadState* __tstate = wxPyBeginAllowThreads();
7585         result = (wxSplitMode)((wxSplitterWindow const *)arg1)->GetSplitMode();
7586
7587         wxPyEndAllowThreads(__tstate);
7588         if (PyErr_Occurred()) SWIG_fail;
7589     }
7590     resultobj = SWIG_From_int((result));
7591     return resultobj;
7592     fail:
7593     return NULL;
7594 }
7595
7596
7597 static PyObject *_wrap_SplitterWindow_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
7598     PyObject *resultobj;
7599     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7600     wxWindow *arg2 = (wxWindow *) 0 ;
7601     PyObject * obj0 = 0 ;
7602     PyObject * obj1 = 0 ;
7603     char *kwnames[] = {
7604         (char *) "self",(char *) "window", NULL
7605     };
7606
7607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_Initialize",kwnames,&obj0,&obj1)) goto fail;
7608     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7609     if (SWIG_arg_fail(1)) SWIG_fail;
7610     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7611     if (SWIG_arg_fail(2)) SWIG_fail;
7612     {
7613         PyThreadState* __tstate = wxPyBeginAllowThreads();
7614         (arg1)->Initialize(arg2);
7615
7616         wxPyEndAllowThreads(__tstate);
7617         if (PyErr_Occurred()) SWIG_fail;
7618     }
7619     Py_INCREF(Py_None); resultobj = Py_None;
7620     return resultobj;
7621     fail:
7622     return NULL;
7623 }
7624
7625
7626 static PyObject *_wrap_SplitterWindow_SplitVertically(PyObject *, PyObject *args, PyObject *kwargs) {
7627     PyObject *resultobj;
7628     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7629     wxWindow *arg2 = (wxWindow *) 0 ;
7630     wxWindow *arg3 = (wxWindow *) 0 ;
7631     int arg4 = (int) 0 ;
7632     bool result;
7633     PyObject * obj0 = 0 ;
7634     PyObject * obj1 = 0 ;
7635     PyObject * obj2 = 0 ;
7636     PyObject * obj3 = 0 ;
7637     char *kwnames[] = {
7638         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7639     };
7640
7641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitVertically",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7643     if (SWIG_arg_fail(1)) SWIG_fail;
7644     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7645     if (SWIG_arg_fail(2)) SWIG_fail;
7646     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7647     if (SWIG_arg_fail(3)) SWIG_fail;
7648     if (obj3) {
7649         {
7650             arg4 = (int)(SWIG_As_int(obj3));
7651             if (SWIG_arg_fail(4)) SWIG_fail;
7652         }
7653     }
7654     {
7655         PyThreadState* __tstate = wxPyBeginAllowThreads();
7656         result = (bool)(arg1)->SplitVertically(arg2,arg3,arg4);
7657
7658         wxPyEndAllowThreads(__tstate);
7659         if (PyErr_Occurred()) SWIG_fail;
7660     }
7661     {
7662         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7663     }
7664     return resultobj;
7665     fail:
7666     return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_SplitterWindow_SplitHorizontally(PyObject *, PyObject *args, PyObject *kwargs) {
7671     PyObject *resultobj;
7672     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7673     wxWindow *arg2 = (wxWindow *) 0 ;
7674     wxWindow *arg3 = (wxWindow *) 0 ;
7675     int arg4 = (int) 0 ;
7676     bool result;
7677     PyObject * obj0 = 0 ;
7678     PyObject * obj1 = 0 ;
7679     PyObject * obj2 = 0 ;
7680     PyObject * obj3 = 0 ;
7681     char *kwnames[] = {
7682         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7683     };
7684
7685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitHorizontally",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7687     if (SWIG_arg_fail(1)) SWIG_fail;
7688     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7689     if (SWIG_arg_fail(2)) SWIG_fail;
7690     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7691     if (SWIG_arg_fail(3)) SWIG_fail;
7692     if (obj3) {
7693         {
7694             arg4 = (int)(SWIG_As_int(obj3));
7695             if (SWIG_arg_fail(4)) SWIG_fail;
7696         }
7697     }
7698     {
7699         PyThreadState* __tstate = wxPyBeginAllowThreads();
7700         result = (bool)(arg1)->SplitHorizontally(arg2,arg3,arg4);
7701
7702         wxPyEndAllowThreads(__tstate);
7703         if (PyErr_Occurred()) SWIG_fail;
7704     }
7705     {
7706         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7707     }
7708     return resultobj;
7709     fail:
7710     return NULL;
7711 }
7712
7713
7714 static PyObject *_wrap_SplitterWindow_Unsplit(PyObject *, PyObject *args, PyObject *kwargs) {
7715     PyObject *resultobj;
7716     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7717     wxWindow *arg2 = (wxWindow *) NULL ;
7718     bool result;
7719     PyObject * obj0 = 0 ;
7720     PyObject * obj1 = 0 ;
7721     char *kwnames[] = {
7722         (char *) "self",(char *) "toRemove", NULL
7723     };
7724
7725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SplitterWindow_Unsplit",kwnames,&obj0,&obj1)) goto fail;
7726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7727     if (SWIG_arg_fail(1)) SWIG_fail;
7728     if (obj1) {
7729         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7730         if (SWIG_arg_fail(2)) SWIG_fail;
7731     }
7732     {
7733         PyThreadState* __tstate = wxPyBeginAllowThreads();
7734         result = (bool)(arg1)->Unsplit(arg2);
7735
7736         wxPyEndAllowThreads(__tstate);
7737         if (PyErr_Occurred()) SWIG_fail;
7738     }
7739     {
7740         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7741     }
7742     return resultobj;
7743     fail:
7744     return NULL;
7745 }
7746
7747
7748 static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7749     PyObject *resultobj;
7750     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7751     wxWindow *arg2 = (wxWindow *) 0 ;
7752     wxWindow *arg3 = (wxWindow *) 0 ;
7753     bool result;
7754     PyObject * obj0 = 0 ;
7755     PyObject * obj1 = 0 ;
7756     PyObject * obj2 = 0 ;
7757     char *kwnames[] = {
7758         (char *) "self",(char *) "winOld",(char *) "winNew", NULL
7759     };
7760
7761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SplitterWindow_ReplaceWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
7762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7763     if (SWIG_arg_fail(1)) SWIG_fail;
7764     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7765     if (SWIG_arg_fail(2)) SWIG_fail;
7766     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7767     if (SWIG_arg_fail(3)) SWIG_fail;
7768     {
7769         PyThreadState* __tstate = wxPyBeginAllowThreads();
7770         result = (bool)(arg1)->ReplaceWindow(arg2,arg3);
7771
7772         wxPyEndAllowThreads(__tstate);
7773         if (PyErr_Occurred()) SWIG_fail;
7774     }
7775     {
7776         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777     }
7778     return resultobj;
7779     fail:
7780     return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *, PyObject *args, PyObject *kwargs) {
7785     PyObject *resultobj;
7786     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7787     PyObject * obj0 = 0 ;
7788     char *kwnames[] = {
7789         (char *) "self", NULL
7790     };
7791
7792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail;
7793     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7794     if (SWIG_arg_fail(1)) SWIG_fail;
7795     {
7796         PyThreadState* __tstate = wxPyBeginAllowThreads();
7797         (arg1)->UpdateSize();
7798
7799         wxPyEndAllowThreads(__tstate);
7800         if (PyErr_Occurred()) SWIG_fail;
7801     }
7802     Py_INCREF(Py_None); resultobj = Py_None;
7803     return resultobj;
7804     fail:
7805     return NULL;
7806 }
7807
7808
7809 static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *, PyObject *args, PyObject *kwargs) {
7810     PyObject *resultobj;
7811     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7812     bool result;
7813     PyObject * obj0 = 0 ;
7814     char *kwnames[] = {
7815         (char *) "self", NULL
7816     };
7817
7818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_IsSplit",kwnames,&obj0)) goto fail;
7819     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7820     if (SWIG_arg_fail(1)) SWIG_fail;
7821     {
7822         PyThreadState* __tstate = wxPyBeginAllowThreads();
7823         result = (bool)((wxSplitterWindow const *)arg1)->IsSplit();
7824
7825         wxPyEndAllowThreads(__tstate);
7826         if (PyErr_Occurred()) SWIG_fail;
7827     }
7828     {
7829         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7830     }
7831     return resultobj;
7832     fail:
7833     return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_SplitterWindow_SetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7838     PyObject *resultobj;
7839     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7840     int arg2 ;
7841     PyObject * obj0 = 0 ;
7842     PyObject * obj1 = 0 ;
7843     char *kwnames[] = {
7844         (char *) "self",(char *) "width", NULL
7845     };
7846
7847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashSize",kwnames,&obj0,&obj1)) goto fail;
7848     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7849     if (SWIG_arg_fail(1)) SWIG_fail;
7850     {
7851         arg2 = (int)(SWIG_As_int(obj1));
7852         if (SWIG_arg_fail(2)) SWIG_fail;
7853     }
7854     {
7855         PyThreadState* __tstate = wxPyBeginAllowThreads();
7856         (arg1)->SetSashSize(arg2);
7857
7858         wxPyEndAllowThreads(__tstate);
7859         if (PyErr_Occurred()) SWIG_fail;
7860     }
7861     Py_INCREF(Py_None); resultobj = Py_None;
7862     return resultobj;
7863     fail:
7864     return NULL;
7865 }
7866
7867
7868 static PyObject *_wrap_SplitterWindow_SetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7869     PyObject *resultobj;
7870     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7871     int arg2 ;
7872     PyObject * obj0 = 0 ;
7873     PyObject * obj1 = 0 ;
7874     char *kwnames[] = {
7875         (char *) "self",(char *) "width", NULL
7876     };
7877
7878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetBorderSize",kwnames,&obj0,&obj1)) goto fail;
7879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7880     if (SWIG_arg_fail(1)) SWIG_fail;
7881     {
7882         arg2 = (int)(SWIG_As_int(obj1));
7883         if (SWIG_arg_fail(2)) SWIG_fail;
7884     }
7885     {
7886         PyThreadState* __tstate = wxPyBeginAllowThreads();
7887         (arg1)->SetBorderSize(arg2);
7888
7889         wxPyEndAllowThreads(__tstate);
7890         if (PyErr_Occurred()) SWIG_fail;
7891     }
7892     Py_INCREF(Py_None); resultobj = Py_None;
7893     return resultobj;
7894     fail:
7895     return NULL;
7896 }
7897
7898
7899 static PyObject *_wrap_SplitterWindow_GetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7900     PyObject *resultobj;
7901     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7902     int result;
7903     PyObject * obj0 = 0 ;
7904     char *kwnames[] = {
7905         (char *) "self", NULL
7906     };
7907
7908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashSize",kwnames,&obj0)) goto fail;
7909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7910     if (SWIG_arg_fail(1)) SWIG_fail;
7911     {
7912         PyThreadState* __tstate = wxPyBeginAllowThreads();
7913         result = (int)((wxSplitterWindow const *)arg1)->GetSashSize();
7914
7915         wxPyEndAllowThreads(__tstate);
7916         if (PyErr_Occurred()) SWIG_fail;
7917     }
7918     {
7919         resultobj = SWIG_From_int((int)(result));
7920     }
7921     return resultobj;
7922     fail:
7923     return NULL;
7924 }
7925
7926
7927 static PyObject *_wrap_SplitterWindow_GetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7928     PyObject *resultobj;
7929     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7930     int result;
7931     PyObject * obj0 = 0 ;
7932     char *kwnames[] = {
7933         (char *) "self", NULL
7934     };
7935
7936     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetBorderSize",kwnames,&obj0)) goto fail;
7937     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7938     if (SWIG_arg_fail(1)) SWIG_fail;
7939     {
7940         PyThreadState* __tstate = wxPyBeginAllowThreads();
7941         result = (int)((wxSplitterWindow const *)arg1)->GetBorderSize();
7942
7943         wxPyEndAllowThreads(__tstate);
7944         if (PyErr_Occurred()) SWIG_fail;
7945     }
7946     {
7947         resultobj = SWIG_From_int((int)(result));
7948     }
7949     return resultobj;
7950     fail:
7951     return NULL;
7952 }
7953
7954
7955 static PyObject *_wrap_SplitterWindow_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7956     PyObject *resultobj;
7957     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7958     int arg2 ;
7959     bool arg3 = (bool) true ;
7960     PyObject * obj0 = 0 ;
7961     PyObject * obj1 = 0 ;
7962     PyObject * obj2 = 0 ;
7963     char *kwnames[] = {
7964         (char *) "self",(char *) "position",(char *) "redraw", NULL
7965     };
7966
7967     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SplitterWindow_SetSashPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
7968     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7969     if (SWIG_arg_fail(1)) SWIG_fail;
7970     {
7971         arg2 = (int)(SWIG_As_int(obj1));
7972         if (SWIG_arg_fail(2)) SWIG_fail;
7973     }
7974     if (obj2) {
7975         {
7976             arg3 = (bool)(SWIG_As_bool(obj2));
7977             if (SWIG_arg_fail(3)) SWIG_fail;
7978         }
7979     }
7980     {
7981         PyThreadState* __tstate = wxPyBeginAllowThreads();
7982         (arg1)->SetSashPosition(arg2,arg3);
7983
7984         wxPyEndAllowThreads(__tstate);
7985         if (PyErr_Occurred()) SWIG_fail;
7986     }
7987     Py_INCREF(Py_None); resultobj = Py_None;
7988     return resultobj;
7989     fail:
7990     return NULL;
7991 }
7992
7993
7994 static PyObject *_wrap_SplitterWindow_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7995     PyObject *resultobj;
7996     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7997     int result;
7998     PyObject * obj0 = 0 ;
7999     char *kwnames[] = {
8000         (char *) "self", NULL
8001     };
8002
8003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashPosition",kwnames,&obj0)) goto fail;
8004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8005     if (SWIG_arg_fail(1)) SWIG_fail;
8006     {
8007         PyThreadState* __tstate = wxPyBeginAllowThreads();
8008         result = (int)((wxSplitterWindow const *)arg1)->GetSashPosition();
8009
8010         wxPyEndAllowThreads(__tstate);
8011         if (PyErr_Occurred()) SWIG_fail;
8012     }
8013     {
8014         resultobj = SWIG_From_int((int)(result));
8015     }
8016     return resultobj;
8017     fail:
8018     return NULL;
8019 }
8020
8021
8022 static PyObject *_wrap_SplitterWindow_SetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8023     PyObject *resultobj;
8024     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8025     double arg2 ;
8026     PyObject * obj0 = 0 ;
8027     PyObject * obj1 = 0 ;
8028     char *kwnames[] = {
8029         (char *) "self",(char *) "gravity", NULL
8030     };
8031
8032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashGravity",kwnames,&obj0,&obj1)) goto fail;
8033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8034     if (SWIG_arg_fail(1)) SWIG_fail;
8035     {
8036         arg2 = (double)(SWIG_As_double(obj1));
8037         if (SWIG_arg_fail(2)) SWIG_fail;
8038     }
8039     {
8040         PyThreadState* __tstate = wxPyBeginAllowThreads();
8041         (arg1)->SetSashGravity(arg2);
8042
8043         wxPyEndAllowThreads(__tstate);
8044         if (PyErr_Occurred()) SWIG_fail;
8045     }
8046     Py_INCREF(Py_None); resultobj = Py_None;
8047     return resultobj;
8048     fail:
8049     return NULL;
8050 }
8051
8052
8053 static PyObject *_wrap_SplitterWindow_GetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8054     PyObject *resultobj;
8055     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8056     double result;
8057     PyObject * obj0 = 0 ;
8058     char *kwnames[] = {
8059         (char *) "self", NULL
8060     };
8061
8062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashGravity",kwnames,&obj0)) goto fail;
8063     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8064     if (SWIG_arg_fail(1)) SWIG_fail;
8065     {
8066         PyThreadState* __tstate = wxPyBeginAllowThreads();
8067         result = (double)((wxSplitterWindow const *)arg1)->GetSashGravity();
8068
8069         wxPyEndAllowThreads(__tstate);
8070         if (PyErr_Occurred()) SWIG_fail;
8071     }
8072     {
8073         resultobj = SWIG_From_double((double)(result));
8074     }
8075     return resultobj;
8076     fail:
8077     return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_SplitterWindow_SetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8082     PyObject *resultobj;
8083     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8084     int arg2 ;
8085     PyObject * obj0 = 0 ;
8086     PyObject * obj1 = 0 ;
8087     char *kwnames[] = {
8088         (char *) "self",(char *) "min", NULL
8089     };
8090
8091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetMinimumPaneSize",kwnames,&obj0,&obj1)) goto fail;
8092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8093     if (SWIG_arg_fail(1)) SWIG_fail;
8094     {
8095         arg2 = (int)(SWIG_As_int(obj1));
8096         if (SWIG_arg_fail(2)) SWIG_fail;
8097     }
8098     {
8099         PyThreadState* __tstate = wxPyBeginAllowThreads();
8100         (arg1)->SetMinimumPaneSize(arg2);
8101
8102         wxPyEndAllowThreads(__tstate);
8103         if (PyErr_Occurred()) SWIG_fail;
8104     }
8105     Py_INCREF(Py_None); resultobj = Py_None;
8106     return resultobj;
8107     fail:
8108     return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_SplitterWindow_GetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8113     PyObject *resultobj;
8114     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8115     int result;
8116     PyObject * obj0 = 0 ;
8117     char *kwnames[] = {
8118         (char *) "self", NULL
8119     };
8120
8121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetMinimumPaneSize",kwnames,&obj0)) goto fail;
8122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8123     if (SWIG_arg_fail(1)) SWIG_fail;
8124     {
8125         PyThreadState* __tstate = wxPyBeginAllowThreads();
8126         result = (int)((wxSplitterWindow const *)arg1)->GetMinimumPaneSize();
8127
8128         wxPyEndAllowThreads(__tstate);
8129         if (PyErr_Occurred()) SWIG_fail;
8130     }
8131     {
8132         resultobj = SWIG_From_int((int)(result));
8133     }
8134     return resultobj;
8135     fail:
8136     return NULL;
8137 }
8138
8139
8140 static PyObject *_wrap_SplitterWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8141     PyObject *resultobj;
8142     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8143     int arg2 ;
8144     int arg3 ;
8145     int arg4 = (int) 5 ;
8146     bool result;
8147     PyObject * obj0 = 0 ;
8148     PyObject * obj1 = 0 ;
8149     PyObject * obj2 = 0 ;
8150     PyObject * obj3 = 0 ;
8151     char *kwnames[] = {
8152         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
8153     };
8154
8155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8156     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8157     if (SWIG_arg_fail(1)) SWIG_fail;
8158     {
8159         arg2 = (int)(SWIG_As_int(obj1));
8160         if (SWIG_arg_fail(2)) SWIG_fail;
8161     }
8162     {
8163         arg3 = (int)(SWIG_As_int(obj2));
8164         if (SWIG_arg_fail(3)) SWIG_fail;
8165     }
8166     if (obj3) {
8167         {
8168             arg4 = (int)(SWIG_As_int(obj3));
8169             if (SWIG_arg_fail(4)) SWIG_fail;
8170         }
8171     }
8172     {
8173         PyThreadState* __tstate = wxPyBeginAllowThreads();
8174         result = (bool)(arg1)->SashHitTest(arg2,arg3,arg4);
8175
8176         wxPyEndAllowThreads(__tstate);
8177         if (PyErr_Occurred()) SWIG_fail;
8178     }
8179     {
8180         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8181     }
8182     return resultobj;
8183     fail:
8184     return NULL;
8185 }
8186
8187
8188 static PyObject *_wrap_SplitterWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
8189     PyObject *resultobj;
8190     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8191     PyObject * obj0 = 0 ;
8192     char *kwnames[] = {
8193         (char *) "self", NULL
8194     };
8195
8196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_SizeWindows",kwnames,&obj0)) goto fail;
8197     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8198     if (SWIG_arg_fail(1)) SWIG_fail;
8199     {
8200         PyThreadState* __tstate = wxPyBeginAllowThreads();
8201         (arg1)->SizeWindows();
8202
8203         wxPyEndAllowThreads(__tstate);
8204         if (PyErr_Occurred()) SWIG_fail;
8205     }
8206     Py_INCREF(Py_None); resultobj = Py_None;
8207     return resultobj;
8208     fail:
8209     return NULL;
8210 }
8211
8212
8213 static PyObject *_wrap_SplitterWindow_SetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8214     PyObject *resultobj;
8215     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8216     bool arg2 ;
8217     PyObject * obj0 = 0 ;
8218     PyObject * obj1 = 0 ;
8219     char *kwnames[] = {
8220         (char *) "self",(char *) "needUpdating", NULL
8221     };
8222
8223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetNeedUpdating",kwnames,&obj0,&obj1)) goto fail;
8224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8225     if (SWIG_arg_fail(1)) SWIG_fail;
8226     {
8227         arg2 = (bool)(SWIG_As_bool(obj1));
8228         if (SWIG_arg_fail(2)) SWIG_fail;
8229     }
8230     {
8231         PyThreadState* __tstate = wxPyBeginAllowThreads();
8232         (arg1)->SetNeedUpdating(arg2);
8233
8234         wxPyEndAllowThreads(__tstate);
8235         if (PyErr_Occurred()) SWIG_fail;
8236     }
8237     Py_INCREF(Py_None); resultobj = Py_None;
8238     return resultobj;
8239     fail:
8240     return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_SplitterWindow_GetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8245     PyObject *resultobj;
8246     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8247     bool result;
8248     PyObject * obj0 = 0 ;
8249     char *kwnames[] = {
8250         (char *) "self", NULL
8251     };
8252
8253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetNeedUpdating",kwnames,&obj0)) goto fail;
8254     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8255     if (SWIG_arg_fail(1)) SWIG_fail;
8256     {
8257         PyThreadState* __tstate = wxPyBeginAllowThreads();
8258         result = (bool)((wxSplitterWindow const *)arg1)->GetNeedUpdating();
8259
8260         wxPyEndAllowThreads(__tstate);
8261         if (PyErr_Occurred()) SWIG_fail;
8262     }
8263     {
8264         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8265     }
8266     return resultobj;
8267     fail:
8268     return NULL;
8269 }
8270
8271
8272 static PyObject *_wrap_SplitterWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8273     PyObject *resultobj;
8274     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8275     wxVisualAttributes result;
8276     PyObject * obj0 = 0 ;
8277     char *kwnames[] = {
8278         (char *) "variant", NULL
8279     };
8280
8281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SplitterWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8282     if (obj0) {
8283         {
8284             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8285             if (SWIG_arg_fail(1)) SWIG_fail;
8286         }
8287     }
8288     {
8289         if (!wxPyCheckForApp()) SWIG_fail;
8290         PyThreadState* __tstate = wxPyBeginAllowThreads();
8291         result = wxSplitterWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
8292
8293         wxPyEndAllowThreads(__tstate);
8294         if (PyErr_Occurred()) SWIG_fail;
8295     }
8296     {
8297         wxVisualAttributes * resultptr;
8298         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8299         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8300     }
8301     return resultobj;
8302     fail:
8303     return NULL;
8304 }
8305
8306
8307 static PyObject * SplitterWindow_swigregister(PyObject *, PyObject *args) {
8308     PyObject *obj;
8309     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8310     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterWindow, obj);
8311     Py_INCREF(obj);
8312     return Py_BuildValue((char *)"");
8313 }
8314 static PyObject *_wrap_new_SplitterEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8315     PyObject *resultobj;
8316     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
8317     wxSplitterWindow *arg2 = (wxSplitterWindow *) (wxSplitterWindow *) NULL ;
8318     wxSplitterEvent *result;
8319     PyObject * obj0 = 0 ;
8320     PyObject * obj1 = 0 ;
8321     char *kwnames[] = {
8322         (char *) "type",(char *) "splitter", NULL
8323     };
8324
8325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SplitterEvent",kwnames,&obj0,&obj1)) goto fail;
8326     if (obj0) {
8327         {
8328             arg1 = (wxEventType)(SWIG_As_int(obj0));
8329             if (SWIG_arg_fail(1)) SWIG_fail;
8330         }
8331     }
8332     if (obj1) {
8333         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8334         if (SWIG_arg_fail(2)) SWIG_fail;
8335     }
8336     {
8337         PyThreadState* __tstate = wxPyBeginAllowThreads();
8338         result = (wxSplitterEvent *)new wxSplitterEvent(arg1,arg2);
8339
8340         wxPyEndAllowThreads(__tstate);
8341         if (PyErr_Occurred()) SWIG_fail;
8342     }
8343     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterEvent, 1);
8344     return resultobj;
8345     fail:
8346     return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_SplitterEvent_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8351     PyObject *resultobj;
8352     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8353     int arg2 ;
8354     PyObject * obj0 = 0 ;
8355     PyObject * obj1 = 0 ;
8356     char *kwnames[] = {
8357         (char *) "self",(char *) "pos", NULL
8358     };
8359
8360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterEvent_SetSashPosition",kwnames,&obj0,&obj1)) goto fail;
8361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8362     if (SWIG_arg_fail(1)) SWIG_fail;
8363     {
8364         arg2 = (int)(SWIG_As_int(obj1));
8365         if (SWIG_arg_fail(2)) SWIG_fail;
8366     }
8367     {
8368         PyThreadState* __tstate = wxPyBeginAllowThreads();
8369         (arg1)->SetSashPosition(arg2);
8370
8371         wxPyEndAllowThreads(__tstate);
8372         if (PyErr_Occurred()) SWIG_fail;
8373     }
8374     Py_INCREF(Py_None); resultobj = Py_None;
8375     return resultobj;
8376     fail:
8377     return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_SplitterEvent_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8382     PyObject *resultobj;
8383     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8384     int result;
8385     PyObject * obj0 = 0 ;
8386     char *kwnames[] = {
8387         (char *) "self", NULL
8388     };
8389
8390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetSashPosition",kwnames,&obj0)) goto fail;
8391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8392     if (SWIG_arg_fail(1)) SWIG_fail;
8393     {
8394         PyThreadState* __tstate = wxPyBeginAllowThreads();
8395         result = (int)((wxSplitterEvent const *)arg1)->GetSashPosition();
8396
8397         wxPyEndAllowThreads(__tstate);
8398         if (PyErr_Occurred()) SWIG_fail;
8399     }
8400     {
8401         resultobj = SWIG_From_int((int)(result));
8402     }
8403     return resultobj;
8404     fail:
8405     return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_SplitterEvent_GetWindowBeingRemoved(PyObject *, PyObject *args, PyObject *kwargs) {
8410     PyObject *resultobj;
8411     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8412     wxWindow *result;
8413     PyObject * obj0 = 0 ;
8414     char *kwnames[] = {
8415         (char *) "self", NULL
8416     };
8417
8418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetWindowBeingRemoved",kwnames,&obj0)) goto fail;
8419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8420     if (SWIG_arg_fail(1)) SWIG_fail;
8421     {
8422         PyThreadState* __tstate = wxPyBeginAllowThreads();
8423         result = (wxWindow *)((wxSplitterEvent const *)arg1)->GetWindowBeingRemoved();
8424
8425         wxPyEndAllowThreads(__tstate);
8426         if (PyErr_Occurred()) SWIG_fail;
8427     }
8428     {
8429         resultobj = wxPyMake_wxObject(result, 0);
8430     }
8431     return resultobj;
8432     fail:
8433     return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_SplitterEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
8438     PyObject *resultobj;
8439     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8440     int result;
8441     PyObject * obj0 = 0 ;
8442     char *kwnames[] = {
8443         (char *) "self", NULL
8444     };
8445
8446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetX",kwnames,&obj0)) goto fail;
8447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8448     if (SWIG_arg_fail(1)) SWIG_fail;
8449     {
8450         PyThreadState* __tstate = wxPyBeginAllowThreads();
8451         result = (int)((wxSplitterEvent const *)arg1)->GetX();
8452
8453         wxPyEndAllowThreads(__tstate);
8454         if (PyErr_Occurred()) SWIG_fail;
8455     }
8456     {
8457         resultobj = SWIG_From_int((int)(result));
8458     }
8459     return resultobj;
8460     fail:
8461     return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_SplitterEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
8466     PyObject *resultobj;
8467     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8468     int result;
8469     PyObject * obj0 = 0 ;
8470     char *kwnames[] = {
8471         (char *) "self", NULL
8472     };
8473
8474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetY",kwnames,&obj0)) goto fail;
8475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8476     if (SWIG_arg_fail(1)) SWIG_fail;
8477     {
8478         PyThreadState* __tstate = wxPyBeginAllowThreads();
8479         result = (int)((wxSplitterEvent const *)arg1)->GetY();
8480
8481         wxPyEndAllowThreads(__tstate);
8482         if (PyErr_Occurred()) SWIG_fail;
8483     }
8484     {
8485         resultobj = SWIG_From_int((int)(result));
8486     }
8487     return resultobj;
8488     fail:
8489     return NULL;
8490 }
8491
8492
8493 static PyObject * SplitterEvent_swigregister(PyObject *, PyObject *args) {
8494     PyObject *obj;
8495     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8496     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterEvent, obj);
8497     Py_INCREF(obj);
8498     return Py_BuildValue((char *)"");
8499 }
8500 static int _wrap_SashNameStr_set(PyObject *) {
8501     PyErr_SetString(PyExc_TypeError,"Variable SashNameStr is read-only.");
8502     return 1;
8503 }
8504
8505
8506 static PyObject *_wrap_SashNameStr_get(void) {
8507     PyObject *pyobj;
8508
8509     {
8510 #if wxUSE_UNICODE
8511         pyobj = PyUnicode_FromWideChar((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8512 #else
8513         pyobj = PyString_FromStringAndSize((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8514 #endif
8515     }
8516     return pyobj;
8517 }
8518
8519
8520 static int _wrap_SashLayoutNameStr_set(PyObject *) {
8521     PyErr_SetString(PyExc_TypeError,"Variable SashLayoutNameStr is read-only.");
8522     return 1;
8523 }
8524
8525
8526 static PyObject *_wrap_SashLayoutNameStr_get(void) {
8527     PyObject *pyobj;
8528
8529     {
8530 #if wxUSE_UNICODE
8531         pyobj = PyUnicode_FromWideChar((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8532 #else
8533         pyobj = PyString_FromStringAndSize((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8534 #endif
8535     }
8536     return pyobj;
8537 }
8538
8539
8540 static PyObject *_wrap_new_SashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8541     PyObject *resultobj;
8542     wxWindow *arg1 = (wxWindow *) 0 ;
8543     int arg2 = (int) -1 ;
8544     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8545     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8546     wxSize const &arg4_defvalue = wxDefaultSize ;
8547     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8548     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8549     wxString const &arg6_defvalue = wxPySashNameStr ;
8550     wxString *arg6 = (wxString *) &arg6_defvalue ;
8551     wxSashWindow *result;
8552     wxPoint temp3 ;
8553     wxSize temp4 ;
8554     bool temp6 = false ;
8555     PyObject * obj0 = 0 ;
8556     PyObject * obj1 = 0 ;
8557     PyObject * obj2 = 0 ;
8558     PyObject * obj3 = 0 ;
8559     PyObject * obj4 = 0 ;
8560     PyObject * obj5 = 0 ;
8561     char *kwnames[] = {
8562         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8563     };
8564
8565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
8566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8567     if (SWIG_arg_fail(1)) SWIG_fail;
8568     if (obj1) {
8569         {
8570             arg2 = (int)(SWIG_As_int(obj1));
8571             if (SWIG_arg_fail(2)) SWIG_fail;
8572         }
8573     }
8574     if (obj2) {
8575         {
8576             arg3 = &temp3;
8577             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8578         }
8579     }
8580     if (obj3) {
8581         {
8582             arg4 = &temp4;
8583             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8584         }
8585     }
8586     if (obj4) {
8587         {
8588             arg5 = (long)(SWIG_As_long(obj4));
8589             if (SWIG_arg_fail(5)) SWIG_fail;
8590         }
8591     }
8592     if (obj5) {
8593         {
8594             arg6 = wxString_in_helper(obj5);
8595             if (arg6 == NULL) SWIG_fail;
8596             temp6 = true;
8597         }
8598     }
8599     {
8600         if (!wxPyCheckForApp()) SWIG_fail;
8601         PyThreadState* __tstate = wxPyBeginAllowThreads();
8602         result = (wxSashWindow *)new wxSashWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
8603
8604         wxPyEndAllowThreads(__tstate);
8605         if (PyErr_Occurred()) SWIG_fail;
8606     }
8607     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8608     {
8609         if (temp6)
8610         delete arg6;
8611     }
8612     return resultobj;
8613     fail:
8614     {
8615         if (temp6)
8616         delete arg6;
8617     }
8618     return NULL;
8619 }
8620
8621
8622 static PyObject *_wrap_new_PreSashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8623     PyObject *resultobj;
8624     wxSashWindow *result;
8625     char *kwnames[] = {
8626         NULL
8627     };
8628
8629     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashWindow",kwnames)) goto fail;
8630     {
8631         if (!wxPyCheckForApp()) SWIG_fail;
8632         PyThreadState* __tstate = wxPyBeginAllowThreads();
8633         result = (wxSashWindow *)new wxSashWindow();
8634
8635         wxPyEndAllowThreads(__tstate);
8636         if (PyErr_Occurred()) SWIG_fail;
8637     }
8638     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8639     return resultobj;
8640     fail:
8641     return NULL;
8642 }
8643
8644
8645 static PyObject *_wrap_SashWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8646     PyObject *resultobj;
8647     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8648     wxWindow *arg2 = (wxWindow *) 0 ;
8649     int arg3 = (int) -1 ;
8650     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8651     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8652     wxSize const &arg5_defvalue = wxDefaultSize ;
8653     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8654     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8655     wxString const &arg7_defvalue = wxPySashNameStr ;
8656     wxString *arg7 = (wxString *) &arg7_defvalue ;
8657     bool result;
8658     wxPoint temp4 ;
8659     wxSize temp5 ;
8660     bool temp7 = false ;
8661     PyObject * obj0 = 0 ;
8662     PyObject * obj1 = 0 ;
8663     PyObject * obj2 = 0 ;
8664     PyObject * obj3 = 0 ;
8665     PyObject * obj4 = 0 ;
8666     PyObject * obj5 = 0 ;
8667     PyObject * obj6 = 0 ;
8668     char *kwnames[] = {
8669         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8670     };
8671
8672     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
8673     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8674     if (SWIG_arg_fail(1)) SWIG_fail;
8675     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8676     if (SWIG_arg_fail(2)) SWIG_fail;
8677     if (obj2) {
8678         {
8679             arg3 = (int)(SWIG_As_int(obj2));
8680             if (SWIG_arg_fail(3)) SWIG_fail;
8681         }
8682     }
8683     if (obj3) {
8684         {
8685             arg4 = &temp4;
8686             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8687         }
8688     }
8689     if (obj4) {
8690         {
8691             arg5 = &temp5;
8692             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8693         }
8694     }
8695     if (obj5) {
8696         {
8697             arg6 = (long)(SWIG_As_long(obj5));
8698             if (SWIG_arg_fail(6)) SWIG_fail;
8699         }
8700     }
8701     if (obj6) {
8702         {
8703             arg7 = wxString_in_helper(obj6);
8704             if (arg7 == NULL) SWIG_fail;
8705             temp7 = true;
8706         }
8707     }
8708     {
8709         PyThreadState* __tstate = wxPyBeginAllowThreads();
8710         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
8711
8712         wxPyEndAllowThreads(__tstate);
8713         if (PyErr_Occurred()) SWIG_fail;
8714     }
8715     {
8716         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8717     }
8718     {
8719         if (temp7)
8720         delete arg7;
8721     }
8722     return resultobj;
8723     fail:
8724     {
8725         if (temp7)
8726         delete arg7;
8727     }
8728     return NULL;
8729 }
8730
8731
8732 static PyObject *_wrap_SashWindow_SetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8733     PyObject *resultobj;
8734     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8735     wxSashEdgePosition arg2 ;
8736     bool arg3 ;
8737     PyObject * obj0 = 0 ;
8738     PyObject * obj1 = 0 ;
8739     PyObject * obj2 = 0 ;
8740     char *kwnames[] = {
8741         (char *) "self",(char *) "edge",(char *) "sash", NULL
8742     };
8743
8744     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
8745     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8746     if (SWIG_arg_fail(1)) SWIG_fail;
8747     {
8748         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8749         if (SWIG_arg_fail(2)) SWIG_fail;
8750     }
8751     {
8752         arg3 = (bool)(SWIG_As_bool(obj2));
8753         if (SWIG_arg_fail(3)) SWIG_fail;
8754     }
8755     {
8756         PyThreadState* __tstate = wxPyBeginAllowThreads();
8757         (arg1)->SetSashVisible((wxSashEdgePosition )arg2,arg3);
8758
8759         wxPyEndAllowThreads(__tstate);
8760         if (PyErr_Occurred()) SWIG_fail;
8761     }
8762     Py_INCREF(Py_None); resultobj = Py_None;
8763     return resultobj;
8764     fail:
8765     return NULL;
8766 }
8767
8768
8769 static PyObject *_wrap_SashWindow_GetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8770     PyObject *resultobj;
8771     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8772     wxSashEdgePosition arg2 ;
8773     bool result;
8774     PyObject * obj0 = 0 ;
8775     PyObject * obj1 = 0 ;
8776     char *kwnames[] = {
8777         (char *) "self",(char *) "edge", NULL
8778     };
8779
8780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetSashVisible",kwnames,&obj0,&obj1)) goto fail;
8781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8782     if (SWIG_arg_fail(1)) SWIG_fail;
8783     {
8784         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8785         if (SWIG_arg_fail(2)) SWIG_fail;
8786     }
8787     {
8788         PyThreadState* __tstate = wxPyBeginAllowThreads();
8789         result = (bool)((wxSashWindow const *)arg1)->GetSashVisible((wxSashEdgePosition )arg2);
8790
8791         wxPyEndAllowThreads(__tstate);
8792         if (PyErr_Occurred()) SWIG_fail;
8793     }
8794     {
8795         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8796     }
8797     return resultobj;
8798     fail:
8799     return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_SashWindow_SetSashBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8804     PyObject *resultobj;
8805     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8806     wxSashEdgePosition arg2 ;
8807     bool arg3 ;
8808     PyObject * obj0 = 0 ;
8809     PyObject * obj1 = 0 ;
8810     PyObject * obj2 = 0 ;
8811     char *kwnames[] = {
8812         (char *) "self",(char *) "edge",(char *) "border", NULL
8813     };
8814
8815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashBorder",kwnames,&obj0,&obj1,&obj2)) goto fail;
8816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8817     if (SWIG_arg_fail(1)) SWIG_fail;
8818     {
8819         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8820         if (SWIG_arg_fail(2)) SWIG_fail;
8821     }
8822     {
8823         arg3 = (bool)(SWIG_As_bool(obj2));
8824         if (SWIG_arg_fail(3)) SWIG_fail;
8825     }
8826     {
8827         PyThreadState* __tstate = wxPyBeginAllowThreads();
8828         (arg1)->SetSashBorder((wxSashEdgePosition )arg2,arg3);
8829
8830         wxPyEndAllowThreads(__tstate);
8831         if (PyErr_Occurred()) SWIG_fail;
8832     }
8833     Py_INCREF(Py_None); resultobj = Py_None;
8834     return resultobj;
8835     fail:
8836     return NULL;
8837 }
8838
8839
8840 static PyObject *_wrap_SashWindow_HasBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8841     PyObject *resultobj;
8842     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8843     wxSashEdgePosition arg2 ;
8844     bool result;
8845     PyObject * obj0 = 0 ;
8846     PyObject * obj1 = 0 ;
8847     char *kwnames[] = {
8848         (char *) "self",(char *) "edge", NULL
8849     };
8850
8851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_HasBorder",kwnames,&obj0,&obj1)) goto fail;
8852     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8853     if (SWIG_arg_fail(1)) SWIG_fail;
8854     {
8855         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8856         if (SWIG_arg_fail(2)) SWIG_fail;
8857     }
8858     {
8859         PyThreadState* __tstate = wxPyBeginAllowThreads();
8860         result = (bool)((wxSashWindow const *)arg1)->HasBorder((wxSashEdgePosition )arg2);
8861
8862         wxPyEndAllowThreads(__tstate);
8863         if (PyErr_Occurred()) SWIG_fail;
8864     }
8865     {
8866         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8867     }
8868     return resultobj;
8869     fail:
8870     return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_SashWindow_GetEdgeMargin(PyObject *, PyObject *args, PyObject *kwargs) {
8875     PyObject *resultobj;
8876     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8877     wxSashEdgePosition arg2 ;
8878     int result;
8879     PyObject * obj0 = 0 ;
8880     PyObject * obj1 = 0 ;
8881     char *kwnames[] = {
8882         (char *) "self",(char *) "edge", NULL
8883     };
8884
8885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetEdgeMargin",kwnames,&obj0,&obj1)) goto fail;
8886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8887     if (SWIG_arg_fail(1)) SWIG_fail;
8888     {
8889         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8890         if (SWIG_arg_fail(2)) SWIG_fail;
8891     }
8892     {
8893         PyThreadState* __tstate = wxPyBeginAllowThreads();
8894         result = (int)((wxSashWindow const *)arg1)->GetEdgeMargin((wxSashEdgePosition )arg2);
8895
8896         wxPyEndAllowThreads(__tstate);
8897         if (PyErr_Occurred()) SWIG_fail;
8898     }
8899     {
8900         resultobj = SWIG_From_int((int)(result));
8901     }
8902     return resultobj;
8903     fail:
8904     return NULL;
8905 }
8906
8907
8908 static PyObject *_wrap_SashWindow_SetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8909     PyObject *resultobj;
8910     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8911     int arg2 ;
8912     PyObject * obj0 = 0 ;
8913     PyObject * obj1 = 0 ;
8914     char *kwnames[] = {
8915         (char *) "self",(char *) "width", NULL
8916     };
8917
8918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetDefaultBorderSize",kwnames,&obj0,&obj1)) goto fail;
8919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8920     if (SWIG_arg_fail(1)) SWIG_fail;
8921     {
8922         arg2 = (int)(SWIG_As_int(obj1));
8923         if (SWIG_arg_fail(2)) SWIG_fail;
8924     }
8925     {
8926         PyThreadState* __tstate = wxPyBeginAllowThreads();
8927         (arg1)->SetDefaultBorderSize(arg2);
8928
8929         wxPyEndAllowThreads(__tstate);
8930         if (PyErr_Occurred()) SWIG_fail;
8931     }
8932     Py_INCREF(Py_None); resultobj = Py_None;
8933     return resultobj;
8934     fail:
8935     return NULL;
8936 }
8937
8938
8939 static PyObject *_wrap_SashWindow_GetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8940     PyObject *resultobj;
8941     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8942     int result;
8943     PyObject * obj0 = 0 ;
8944     char *kwnames[] = {
8945         (char *) "self", NULL
8946     };
8947
8948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetDefaultBorderSize",kwnames,&obj0)) goto fail;
8949     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8950     if (SWIG_arg_fail(1)) SWIG_fail;
8951     {
8952         PyThreadState* __tstate = wxPyBeginAllowThreads();
8953         result = (int)((wxSashWindow const *)arg1)->GetDefaultBorderSize();
8954
8955         wxPyEndAllowThreads(__tstate);
8956         if (PyErr_Occurred()) SWIG_fail;
8957     }
8958     {
8959         resultobj = SWIG_From_int((int)(result));
8960     }
8961     return resultobj;
8962     fail:
8963     return NULL;
8964 }
8965
8966
8967 static PyObject *_wrap_SashWindow_SetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8968     PyObject *resultobj;
8969     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8970     int arg2 ;
8971     PyObject * obj0 = 0 ;
8972     PyObject * obj1 = 0 ;
8973     char *kwnames[] = {
8974         (char *) "self",(char *) "width", NULL
8975     };
8976
8977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetExtraBorderSize",kwnames,&obj0,&obj1)) goto fail;
8978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8979     if (SWIG_arg_fail(1)) SWIG_fail;
8980     {
8981         arg2 = (int)(SWIG_As_int(obj1));
8982         if (SWIG_arg_fail(2)) SWIG_fail;
8983     }
8984     {
8985         PyThreadState* __tstate = wxPyBeginAllowThreads();
8986         (arg1)->SetExtraBorderSize(arg2);
8987
8988         wxPyEndAllowThreads(__tstate);
8989         if (PyErr_Occurred()) SWIG_fail;
8990     }
8991     Py_INCREF(Py_None); resultobj = Py_None;
8992     return resultobj;
8993     fail:
8994     return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_SashWindow_GetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8999     PyObject *resultobj;
9000     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9001     int result;
9002     PyObject * obj0 = 0 ;
9003     char *kwnames[] = {
9004         (char *) "self", NULL
9005     };
9006
9007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetExtraBorderSize",kwnames,&obj0)) goto fail;
9008     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9009     if (SWIG_arg_fail(1)) SWIG_fail;
9010     {
9011         PyThreadState* __tstate = wxPyBeginAllowThreads();
9012         result = (int)((wxSashWindow const *)arg1)->GetExtraBorderSize();
9013
9014         wxPyEndAllowThreads(__tstate);
9015         if (PyErr_Occurred()) SWIG_fail;
9016     }
9017     {
9018         resultobj = SWIG_From_int((int)(result));
9019     }
9020     return resultobj;
9021     fail:
9022     return NULL;
9023 }
9024
9025
9026 static PyObject *_wrap_SashWindow_SetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9027     PyObject *resultobj;
9028     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9029     int arg2 ;
9030     PyObject * obj0 = 0 ;
9031     PyObject * obj1 = 0 ;
9032     char *kwnames[] = {
9033         (char *) "self",(char *) "min", NULL
9034     };
9035
9036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeX",kwnames,&obj0,&obj1)) goto fail;
9037     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9038     if (SWIG_arg_fail(1)) SWIG_fail;
9039     {
9040         arg2 = (int)(SWIG_As_int(obj1));
9041         if (SWIG_arg_fail(2)) SWIG_fail;
9042     }
9043     {
9044         PyThreadState* __tstate = wxPyBeginAllowThreads();
9045         (arg1)->SetMinimumSizeX(arg2);
9046
9047         wxPyEndAllowThreads(__tstate);
9048         if (PyErr_Occurred()) SWIG_fail;
9049     }
9050     Py_INCREF(Py_None); resultobj = Py_None;
9051     return resultobj;
9052     fail:
9053     return NULL;
9054 }
9055
9056
9057 static PyObject *_wrap_SashWindow_SetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9058     PyObject *resultobj;
9059     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9060     int arg2 ;
9061     PyObject * obj0 = 0 ;
9062     PyObject * obj1 = 0 ;
9063     char *kwnames[] = {
9064         (char *) "self",(char *) "min", NULL
9065     };
9066
9067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeY",kwnames,&obj0,&obj1)) goto fail;
9068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9069     if (SWIG_arg_fail(1)) SWIG_fail;
9070     {
9071         arg2 = (int)(SWIG_As_int(obj1));
9072         if (SWIG_arg_fail(2)) SWIG_fail;
9073     }
9074     {
9075         PyThreadState* __tstate = wxPyBeginAllowThreads();
9076         (arg1)->SetMinimumSizeY(arg2);
9077
9078         wxPyEndAllowThreads(__tstate);
9079         if (PyErr_Occurred()) SWIG_fail;
9080     }
9081     Py_INCREF(Py_None); resultobj = Py_None;
9082     return resultobj;
9083     fail:
9084     return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_SashWindow_GetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9089     PyObject *resultobj;
9090     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9091     int result;
9092     PyObject * obj0 = 0 ;
9093     char *kwnames[] = {
9094         (char *) "self", NULL
9095     };
9096
9097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeX",kwnames,&obj0)) goto fail;
9098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9099     if (SWIG_arg_fail(1)) SWIG_fail;
9100     {
9101         PyThreadState* __tstate = wxPyBeginAllowThreads();
9102         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeX();
9103
9104         wxPyEndAllowThreads(__tstate);
9105         if (PyErr_Occurred()) SWIG_fail;
9106     }
9107     {
9108         resultobj = SWIG_From_int((int)(result));
9109     }
9110     return resultobj;
9111     fail:
9112     return NULL;
9113 }
9114
9115
9116 static PyObject *_wrap_SashWindow_GetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9117     PyObject *resultobj;
9118     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9119     int result;
9120     PyObject * obj0 = 0 ;
9121     char *kwnames[] = {
9122         (char *) "self", NULL
9123     };
9124
9125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeY",kwnames,&obj0)) goto fail;
9126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9127     if (SWIG_arg_fail(1)) SWIG_fail;
9128     {
9129         PyThreadState* __tstate = wxPyBeginAllowThreads();
9130         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeY();
9131
9132         wxPyEndAllowThreads(__tstate);
9133         if (PyErr_Occurred()) SWIG_fail;
9134     }
9135     {
9136         resultobj = SWIG_From_int((int)(result));
9137     }
9138     return resultobj;
9139     fail:
9140     return NULL;
9141 }
9142
9143
9144 static PyObject *_wrap_SashWindow_SetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9145     PyObject *resultobj;
9146     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9147     int arg2 ;
9148     PyObject * obj0 = 0 ;
9149     PyObject * obj1 = 0 ;
9150     char *kwnames[] = {
9151         (char *) "self",(char *) "max", NULL
9152     };
9153
9154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeX",kwnames,&obj0,&obj1)) goto fail;
9155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9156     if (SWIG_arg_fail(1)) SWIG_fail;
9157     {
9158         arg2 = (int)(SWIG_As_int(obj1));
9159         if (SWIG_arg_fail(2)) SWIG_fail;
9160     }
9161     {
9162         PyThreadState* __tstate = wxPyBeginAllowThreads();
9163         (arg1)->SetMaximumSizeX(arg2);
9164
9165         wxPyEndAllowThreads(__tstate);
9166         if (PyErr_Occurred()) SWIG_fail;
9167     }
9168     Py_INCREF(Py_None); resultobj = Py_None;
9169     return resultobj;
9170     fail:
9171     return NULL;
9172 }
9173
9174
9175 static PyObject *_wrap_SashWindow_SetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9176     PyObject *resultobj;
9177     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9178     int arg2 ;
9179     PyObject * obj0 = 0 ;
9180     PyObject * obj1 = 0 ;
9181     char *kwnames[] = {
9182         (char *) "self",(char *) "max", NULL
9183     };
9184
9185     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeY",kwnames,&obj0,&obj1)) goto fail;
9186     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9187     if (SWIG_arg_fail(1)) SWIG_fail;
9188     {
9189         arg2 = (int)(SWIG_As_int(obj1));
9190         if (SWIG_arg_fail(2)) SWIG_fail;
9191     }
9192     {
9193         PyThreadState* __tstate = wxPyBeginAllowThreads();
9194         (arg1)->SetMaximumSizeY(arg2);
9195
9196         wxPyEndAllowThreads(__tstate);
9197         if (PyErr_Occurred()) SWIG_fail;
9198     }
9199     Py_INCREF(Py_None); resultobj = Py_None;
9200     return resultobj;
9201     fail:
9202     return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_SashWindow_GetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9207     PyObject *resultobj;
9208     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9209     int result;
9210     PyObject * obj0 = 0 ;
9211     char *kwnames[] = {
9212         (char *) "self", NULL
9213     };
9214
9215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeX",kwnames,&obj0)) goto fail;
9216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9217     if (SWIG_arg_fail(1)) SWIG_fail;
9218     {
9219         PyThreadState* __tstate = wxPyBeginAllowThreads();
9220         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeX();
9221
9222         wxPyEndAllowThreads(__tstate);
9223         if (PyErr_Occurred()) SWIG_fail;
9224     }
9225     {
9226         resultobj = SWIG_From_int((int)(result));
9227     }
9228     return resultobj;
9229     fail:
9230     return NULL;
9231 }
9232
9233
9234 static PyObject *_wrap_SashWindow_GetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9235     PyObject *resultobj;
9236     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9237     int result;
9238     PyObject * obj0 = 0 ;
9239     char *kwnames[] = {
9240         (char *) "self", NULL
9241     };
9242
9243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeY",kwnames,&obj0)) goto fail;
9244     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9245     if (SWIG_arg_fail(1)) SWIG_fail;
9246     {
9247         PyThreadState* __tstate = wxPyBeginAllowThreads();
9248         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeY();
9249
9250         wxPyEndAllowThreads(__tstate);
9251         if (PyErr_Occurred()) SWIG_fail;
9252     }
9253     {
9254         resultobj = SWIG_From_int((int)(result));
9255     }
9256     return resultobj;
9257     fail:
9258     return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_SashWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
9263     PyObject *resultobj;
9264     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9265     int arg2 ;
9266     int arg3 ;
9267     int arg4 = (int) 2 ;
9268     wxSashEdgePosition result;
9269     PyObject * obj0 = 0 ;
9270     PyObject * obj1 = 0 ;
9271     PyObject * obj2 = 0 ;
9272     PyObject * obj3 = 0 ;
9273     char *kwnames[] = {
9274         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
9275     };
9276
9277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SashWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) 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         arg2 = (int)(SWIG_As_int(obj1));
9282         if (SWIG_arg_fail(2)) SWIG_fail;
9283     }
9284     {
9285         arg3 = (int)(SWIG_As_int(obj2));
9286         if (SWIG_arg_fail(3)) SWIG_fail;
9287     }
9288     if (obj3) {
9289         {
9290             arg4 = (int)(SWIG_As_int(obj3));
9291             if (SWIG_arg_fail(4)) SWIG_fail;
9292         }
9293     }
9294     {
9295         PyThreadState* __tstate = wxPyBeginAllowThreads();
9296         result = (wxSashEdgePosition)(arg1)->SashHitTest(arg2,arg3,arg4);
9297
9298         wxPyEndAllowThreads(__tstate);
9299         if (PyErr_Occurred()) SWIG_fail;
9300     }
9301     resultobj = SWIG_From_int((result));
9302     return resultobj;
9303     fail:
9304     return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_SashWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
9309     PyObject *resultobj;
9310     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9311     PyObject * obj0 = 0 ;
9312     char *kwnames[] = {
9313         (char *) "self", NULL
9314     };
9315
9316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_SizeWindows",kwnames,&obj0)) goto fail;
9317     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9318     if (SWIG_arg_fail(1)) SWIG_fail;
9319     {
9320         PyThreadState* __tstate = wxPyBeginAllowThreads();
9321         (arg1)->SizeWindows();
9322
9323         wxPyEndAllowThreads(__tstate);
9324         if (PyErr_Occurred()) SWIG_fail;
9325     }
9326     Py_INCREF(Py_None); resultobj = Py_None;
9327     return resultobj;
9328     fail:
9329     return NULL;
9330 }
9331
9332
9333 static PyObject * SashWindow_swigregister(PyObject *, PyObject *args) {
9334     PyObject *obj;
9335     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9336     SWIG_TypeClientData(SWIGTYPE_p_wxSashWindow, obj);
9337     Py_INCREF(obj);
9338     return Py_BuildValue((char *)"");
9339 }
9340 static PyObject *_wrap_new_SashEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9341     PyObject *resultobj;
9342     int arg1 = (int) 0 ;
9343     wxSashEdgePosition arg2 = (wxSashEdgePosition) wxSASH_NONE ;
9344     wxSashEvent *result;
9345     PyObject * obj0 = 0 ;
9346     PyObject * obj1 = 0 ;
9347     char *kwnames[] = {
9348         (char *) "id",(char *) "edge", NULL
9349     };
9350
9351     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SashEvent",kwnames,&obj0,&obj1)) goto fail;
9352     if (obj0) {
9353         {
9354             arg1 = (int)(SWIG_As_int(obj0));
9355             if (SWIG_arg_fail(1)) SWIG_fail;
9356         }
9357     }
9358     if (obj1) {
9359         {
9360             arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9361             if (SWIG_arg_fail(2)) SWIG_fail;
9362         }
9363     }
9364     {
9365         PyThreadState* __tstate = wxPyBeginAllowThreads();
9366         result = (wxSashEvent *)new wxSashEvent(arg1,(wxSashEdgePosition )arg2);
9367
9368         wxPyEndAllowThreads(__tstate);
9369         if (PyErr_Occurred()) SWIG_fail;
9370     }
9371     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashEvent, 1);
9372     return resultobj;
9373     fail:
9374     return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_SashEvent_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9379     PyObject *resultobj;
9380     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9381     wxSashEdgePosition arg2 ;
9382     PyObject * obj0 = 0 ;
9383     PyObject * obj1 = 0 ;
9384     char *kwnames[] = {
9385         (char *) "self",(char *) "edge", NULL
9386     };
9387
9388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetEdge",kwnames,&obj0,&obj1)) goto fail;
9389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9390     if (SWIG_arg_fail(1)) SWIG_fail;
9391     {
9392         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9393         if (SWIG_arg_fail(2)) SWIG_fail;
9394     }
9395     {
9396         PyThreadState* __tstate = wxPyBeginAllowThreads();
9397         (arg1)->SetEdge((wxSashEdgePosition )arg2);
9398
9399         wxPyEndAllowThreads(__tstate);
9400         if (PyErr_Occurred()) SWIG_fail;
9401     }
9402     Py_INCREF(Py_None); resultobj = Py_None;
9403     return resultobj;
9404     fail:
9405     return NULL;
9406 }
9407
9408
9409 static PyObject *_wrap_SashEvent_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9410     PyObject *resultobj;
9411     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9412     wxSashEdgePosition result;
9413     PyObject * obj0 = 0 ;
9414     char *kwnames[] = {
9415         (char *) "self", NULL
9416     };
9417
9418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetEdge",kwnames,&obj0)) goto fail;
9419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9420     if (SWIG_arg_fail(1)) SWIG_fail;
9421     {
9422         PyThreadState* __tstate = wxPyBeginAllowThreads();
9423         result = (wxSashEdgePosition)((wxSashEvent const *)arg1)->GetEdge();
9424
9425         wxPyEndAllowThreads(__tstate);
9426         if (PyErr_Occurred()) SWIG_fail;
9427     }
9428     resultobj = SWIG_From_int((result));
9429     return resultobj;
9430     fail:
9431     return NULL;
9432 }
9433
9434
9435 static PyObject *_wrap_SashEvent_SetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9436     PyObject *resultobj;
9437     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9438     wxRect *arg2 = 0 ;
9439     wxRect temp2 ;
9440     PyObject * obj0 = 0 ;
9441     PyObject * obj1 = 0 ;
9442     char *kwnames[] = {
9443         (char *) "self",(char *) "rect", NULL
9444     };
9445
9446     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragRect",kwnames,&obj0,&obj1)) goto fail;
9447     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9448     if (SWIG_arg_fail(1)) SWIG_fail;
9449     {
9450         arg2 = &temp2;
9451         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
9452     }
9453     {
9454         PyThreadState* __tstate = wxPyBeginAllowThreads();
9455         (arg1)->SetDragRect((wxRect const &)*arg2);
9456
9457         wxPyEndAllowThreads(__tstate);
9458         if (PyErr_Occurred()) SWIG_fail;
9459     }
9460     Py_INCREF(Py_None); resultobj = Py_None;
9461     return resultobj;
9462     fail:
9463     return NULL;
9464 }
9465
9466
9467 static PyObject *_wrap_SashEvent_GetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9468     PyObject *resultobj;
9469     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9470     wxRect result;
9471     PyObject * obj0 = 0 ;
9472     char *kwnames[] = {
9473         (char *) "self", NULL
9474     };
9475
9476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragRect",kwnames,&obj0)) goto fail;
9477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9478     if (SWIG_arg_fail(1)) SWIG_fail;
9479     {
9480         PyThreadState* __tstate = wxPyBeginAllowThreads();
9481         result = ((wxSashEvent const *)arg1)->GetDragRect();
9482
9483         wxPyEndAllowThreads(__tstate);
9484         if (PyErr_Occurred()) SWIG_fail;
9485     }
9486     {
9487         wxRect * resultptr;
9488         resultptr = new wxRect((wxRect &)(result));
9489         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
9490     }
9491     return resultobj;
9492     fail:
9493     return NULL;
9494 }
9495
9496
9497 static PyObject *_wrap_SashEvent_SetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9498     PyObject *resultobj;
9499     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9500     wxSashDragStatus arg2 ;
9501     PyObject * obj0 = 0 ;
9502     PyObject * obj1 = 0 ;
9503     char *kwnames[] = {
9504         (char *) "self",(char *) "status", NULL
9505     };
9506
9507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragStatus",kwnames,&obj0,&obj1)) goto fail;
9508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9509     if (SWIG_arg_fail(1)) SWIG_fail;
9510     {
9511         arg2 = (wxSashDragStatus)(SWIG_As_int(obj1));
9512         if (SWIG_arg_fail(2)) SWIG_fail;
9513     }
9514     {
9515         PyThreadState* __tstate = wxPyBeginAllowThreads();
9516         (arg1)->SetDragStatus((wxSashDragStatus )arg2);
9517
9518         wxPyEndAllowThreads(__tstate);
9519         if (PyErr_Occurred()) SWIG_fail;
9520     }
9521     Py_INCREF(Py_None); resultobj = Py_None;
9522     return resultobj;
9523     fail:
9524     return NULL;
9525 }
9526
9527
9528 static PyObject *_wrap_SashEvent_GetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9529     PyObject *resultobj;
9530     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9531     wxSashDragStatus result;
9532     PyObject * obj0 = 0 ;
9533     char *kwnames[] = {
9534         (char *) "self", NULL
9535     };
9536
9537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragStatus",kwnames,&obj0)) goto fail;
9538     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9539     if (SWIG_arg_fail(1)) SWIG_fail;
9540     {
9541         PyThreadState* __tstate = wxPyBeginAllowThreads();
9542         result = (wxSashDragStatus)((wxSashEvent const *)arg1)->GetDragStatus();
9543
9544         wxPyEndAllowThreads(__tstate);
9545         if (PyErr_Occurred()) SWIG_fail;
9546     }
9547     resultobj = SWIG_From_int((result));
9548     return resultobj;
9549     fail:
9550     return NULL;
9551 }
9552
9553
9554 static PyObject * SashEvent_swigregister(PyObject *, PyObject *args) {
9555     PyObject *obj;
9556     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9557     SWIG_TypeClientData(SWIGTYPE_p_wxSashEvent, obj);
9558     Py_INCREF(obj);
9559     return Py_BuildValue((char *)"");
9560 }
9561 static PyObject *_wrap_new_QueryLayoutInfoEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9562     PyObject *resultobj;
9563     int arg1 = (int) 0 ;
9564     wxQueryLayoutInfoEvent *result;
9565     PyObject * obj0 = 0 ;
9566     char *kwnames[] = {
9567         (char *) "id", NULL
9568     };
9569
9570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryLayoutInfoEvent",kwnames,&obj0)) goto fail;
9571     if (obj0) {
9572         {
9573             arg1 = (int)(SWIG_As_int(obj0));
9574             if (SWIG_arg_fail(1)) SWIG_fail;
9575         }
9576     }
9577     {
9578         PyThreadState* __tstate = wxPyBeginAllowThreads();
9579         result = (wxQueryLayoutInfoEvent *)new wxQueryLayoutInfoEvent(arg1);
9580
9581         wxPyEndAllowThreads(__tstate);
9582         if (PyErr_Occurred()) SWIG_fail;
9583     }
9584     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryLayoutInfoEvent, 1);
9585     return resultobj;
9586     fail:
9587     return NULL;
9588 }
9589
9590
9591 static PyObject *_wrap_QueryLayoutInfoEvent_SetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9592     PyObject *resultobj;
9593     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9594     int arg2 ;
9595     PyObject * obj0 = 0 ;
9596     PyObject * obj1 = 0 ;
9597     char *kwnames[] = {
9598         (char *) "self",(char *) "length", NULL
9599     };
9600
9601     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetRequestedLength",kwnames,&obj0,&obj1)) goto fail;
9602     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9603     if (SWIG_arg_fail(1)) SWIG_fail;
9604     {
9605         arg2 = (int)(SWIG_As_int(obj1));
9606         if (SWIG_arg_fail(2)) SWIG_fail;
9607     }
9608     {
9609         PyThreadState* __tstate = wxPyBeginAllowThreads();
9610         (arg1)->SetRequestedLength(arg2);
9611
9612         wxPyEndAllowThreads(__tstate);
9613         if (PyErr_Occurred()) SWIG_fail;
9614     }
9615     Py_INCREF(Py_None); resultobj = Py_None;
9616     return resultobj;
9617     fail:
9618     return NULL;
9619 }
9620
9621
9622 static PyObject *_wrap_QueryLayoutInfoEvent_GetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9623     PyObject *resultobj;
9624     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9625     int result;
9626     PyObject * obj0 = 0 ;
9627     char *kwnames[] = {
9628         (char *) "self", NULL
9629     };
9630
9631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetRequestedLength",kwnames,&obj0)) goto fail;
9632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9633     if (SWIG_arg_fail(1)) SWIG_fail;
9634     {
9635         PyThreadState* __tstate = wxPyBeginAllowThreads();
9636         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetRequestedLength();
9637
9638         wxPyEndAllowThreads(__tstate);
9639         if (PyErr_Occurred()) SWIG_fail;
9640     }
9641     {
9642         resultobj = SWIG_From_int((int)(result));
9643     }
9644     return resultobj;
9645     fail:
9646     return NULL;
9647 }
9648
9649
9650 static PyObject *_wrap_QueryLayoutInfoEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9651     PyObject *resultobj;
9652     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9653     int arg2 ;
9654     PyObject * obj0 = 0 ;
9655     PyObject * obj1 = 0 ;
9656     char *kwnames[] = {
9657         (char *) "self",(char *) "flags", NULL
9658     };
9659
9660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9661     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9662     if (SWIG_arg_fail(1)) SWIG_fail;
9663     {
9664         arg2 = (int)(SWIG_As_int(obj1));
9665         if (SWIG_arg_fail(2)) SWIG_fail;
9666     }
9667     {
9668         PyThreadState* __tstate = wxPyBeginAllowThreads();
9669         (arg1)->SetFlags(arg2);
9670
9671         wxPyEndAllowThreads(__tstate);
9672         if (PyErr_Occurred()) SWIG_fail;
9673     }
9674     Py_INCREF(Py_None); resultobj = Py_None;
9675     return resultobj;
9676     fail:
9677     return NULL;
9678 }
9679
9680
9681 static PyObject *_wrap_QueryLayoutInfoEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9682     PyObject *resultobj;
9683     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9684     int result;
9685     PyObject * obj0 = 0 ;
9686     char *kwnames[] = {
9687         (char *) "self", NULL
9688     };
9689
9690     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetFlags",kwnames,&obj0)) goto fail;
9691     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9692     if (SWIG_arg_fail(1)) SWIG_fail;
9693     {
9694         PyThreadState* __tstate = wxPyBeginAllowThreads();
9695         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetFlags();
9696
9697         wxPyEndAllowThreads(__tstate);
9698         if (PyErr_Occurred()) SWIG_fail;
9699     }
9700     {
9701         resultobj = SWIG_From_int((int)(result));
9702     }
9703     return resultobj;
9704     fail:
9705     return NULL;
9706 }
9707
9708
9709 static PyObject *_wrap_QueryLayoutInfoEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9710     PyObject *resultobj;
9711     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9712     wxSize *arg2 = 0 ;
9713     wxSize temp2 ;
9714     PyObject * obj0 = 0 ;
9715     PyObject * obj1 = 0 ;
9716     char *kwnames[] = {
9717         (char *) "self",(char *) "size", NULL
9718     };
9719
9720     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
9721     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9722     if (SWIG_arg_fail(1)) SWIG_fail;
9723     {
9724         arg2 = &temp2;
9725         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9726     }
9727     {
9728         PyThreadState* __tstate = wxPyBeginAllowThreads();
9729         (arg1)->SetSize((wxSize const &)*arg2);
9730
9731         wxPyEndAllowThreads(__tstate);
9732         if (PyErr_Occurred()) SWIG_fail;
9733     }
9734     Py_INCREF(Py_None); resultobj = Py_None;
9735     return resultobj;
9736     fail:
9737     return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_QueryLayoutInfoEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9742     PyObject *resultobj;
9743     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9744     wxSize result;
9745     PyObject * obj0 = 0 ;
9746     char *kwnames[] = {
9747         (char *) "self", NULL
9748     };
9749
9750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetSize",kwnames,&obj0)) goto fail;
9751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9752     if (SWIG_arg_fail(1)) SWIG_fail;
9753     {
9754         PyThreadState* __tstate = wxPyBeginAllowThreads();
9755         result = ((wxQueryLayoutInfoEvent const *)arg1)->GetSize();
9756
9757         wxPyEndAllowThreads(__tstate);
9758         if (PyErr_Occurred()) SWIG_fail;
9759     }
9760     {
9761         wxSize * resultptr;
9762         resultptr = new wxSize((wxSize &)(result));
9763         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9764     }
9765     return resultobj;
9766     fail:
9767     return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_QueryLayoutInfoEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9772     PyObject *resultobj;
9773     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9774     wxLayoutOrientation arg2 ;
9775     PyObject * obj0 = 0 ;
9776     PyObject * obj1 = 0 ;
9777     char *kwnames[] = {
9778         (char *) "self",(char *) "orient", NULL
9779     };
9780
9781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
9782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9783     if (SWIG_arg_fail(1)) SWIG_fail;
9784     {
9785         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
9786         if (SWIG_arg_fail(2)) SWIG_fail;
9787     }
9788     {
9789         PyThreadState* __tstate = wxPyBeginAllowThreads();
9790         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
9791
9792         wxPyEndAllowThreads(__tstate);
9793         if (PyErr_Occurred()) SWIG_fail;
9794     }
9795     Py_INCREF(Py_None); resultobj = Py_None;
9796     return resultobj;
9797     fail:
9798     return NULL;
9799 }
9800
9801
9802 static PyObject *_wrap_QueryLayoutInfoEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9803     PyObject *resultobj;
9804     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9805     wxLayoutOrientation result;
9806     PyObject * obj0 = 0 ;
9807     char *kwnames[] = {
9808         (char *) "self", NULL
9809     };
9810
9811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetOrientation",kwnames,&obj0)) goto fail;
9812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9813     if (SWIG_arg_fail(1)) SWIG_fail;
9814     {
9815         PyThreadState* __tstate = wxPyBeginAllowThreads();
9816         result = (wxLayoutOrientation)((wxQueryLayoutInfoEvent const *)arg1)->GetOrientation();
9817
9818         wxPyEndAllowThreads(__tstate);
9819         if (PyErr_Occurred()) SWIG_fail;
9820     }
9821     resultobj = SWIG_From_int((result));
9822     return resultobj;
9823     fail:
9824     return NULL;
9825 }
9826
9827
9828 static PyObject *_wrap_QueryLayoutInfoEvent_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9829     PyObject *resultobj;
9830     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9831     wxLayoutAlignment arg2 ;
9832     PyObject * obj0 = 0 ;
9833     PyObject * obj1 = 0 ;
9834     char *kwnames[] = {
9835         (char *) "self",(char *) "align", NULL
9836     };
9837
9838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
9839     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9840     if (SWIG_arg_fail(1)) SWIG_fail;
9841     {
9842         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
9843         if (SWIG_arg_fail(2)) SWIG_fail;
9844     }
9845     {
9846         PyThreadState* __tstate = wxPyBeginAllowThreads();
9847         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
9848
9849         wxPyEndAllowThreads(__tstate);
9850         if (PyErr_Occurred()) SWIG_fail;
9851     }
9852     Py_INCREF(Py_None); resultobj = Py_None;
9853     return resultobj;
9854     fail:
9855     return NULL;
9856 }
9857
9858
9859 static PyObject *_wrap_QueryLayoutInfoEvent_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9860     PyObject *resultobj;
9861     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9862     wxLayoutAlignment result;
9863     PyObject * obj0 = 0 ;
9864     char *kwnames[] = {
9865         (char *) "self", NULL
9866     };
9867
9868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetAlignment",kwnames,&obj0)) goto fail;
9869     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9870     if (SWIG_arg_fail(1)) SWIG_fail;
9871     {
9872         PyThreadState* __tstate = wxPyBeginAllowThreads();
9873         result = (wxLayoutAlignment)((wxQueryLayoutInfoEvent const *)arg1)->GetAlignment();
9874
9875         wxPyEndAllowThreads(__tstate);
9876         if (PyErr_Occurred()) SWIG_fail;
9877     }
9878     resultobj = SWIG_From_int((result));
9879     return resultobj;
9880     fail:
9881     return NULL;
9882 }
9883
9884
9885 static PyObject * QueryLayoutInfoEvent_swigregister(PyObject *, PyObject *args) {
9886     PyObject *obj;
9887     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9888     SWIG_TypeClientData(SWIGTYPE_p_wxQueryLayoutInfoEvent, obj);
9889     Py_INCREF(obj);
9890     return Py_BuildValue((char *)"");
9891 }
9892 static PyObject *_wrap_new_CalculateLayoutEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9893     PyObject *resultobj;
9894     int arg1 = (int) 0 ;
9895     wxCalculateLayoutEvent *result;
9896     PyObject * obj0 = 0 ;
9897     char *kwnames[] = {
9898         (char *) "id", NULL
9899     };
9900
9901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CalculateLayoutEvent",kwnames,&obj0)) goto fail;
9902     if (obj0) {
9903         {
9904             arg1 = (int)(SWIG_As_int(obj0));
9905             if (SWIG_arg_fail(1)) SWIG_fail;
9906         }
9907     }
9908     {
9909         PyThreadState* __tstate = wxPyBeginAllowThreads();
9910         result = (wxCalculateLayoutEvent *)new wxCalculateLayoutEvent(arg1);
9911
9912         wxPyEndAllowThreads(__tstate);
9913         if (PyErr_Occurred()) SWIG_fail;
9914     }
9915     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCalculateLayoutEvent, 1);
9916     return resultobj;
9917     fail:
9918     return NULL;
9919 }
9920
9921
9922 static PyObject *_wrap_CalculateLayoutEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9923     PyObject *resultobj;
9924     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
9925     int arg2 ;
9926     PyObject * obj0 = 0 ;
9927     PyObject * obj1 = 0 ;
9928     char *kwnames[] = {
9929         (char *) "self",(char *) "flags", NULL
9930     };
9931
9932     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9933     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
9934     if (SWIG_arg_fail(1)) SWIG_fail;
9935     {
9936         arg2 = (int)(SWIG_As_int(obj1));
9937         if (SWIG_arg_fail(2)) SWIG_fail;
9938     }
9939     {
9940         PyThreadState* __tstate = wxPyBeginAllowThreads();
9941         (arg1)->SetFlags(arg2);
9942
9943         wxPyEndAllowThreads(__tstate);
9944         if (PyErr_Occurred()) SWIG_fail;
9945     }
9946     Py_INCREF(Py_None); resultobj = Py_None;
9947     return resultobj;
9948     fail:
9949     return NULL;
9950 }
9951
9952
9953 static PyObject *_wrap_CalculateLayoutEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9954     PyObject *resultobj;
9955     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
9956     int result;
9957     PyObject * obj0 = 0 ;
9958     char *kwnames[] = {
9959         (char *) "self", NULL
9960     };
9961
9962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetFlags",kwnames,&obj0)) goto fail;
9963     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
9964     if (SWIG_arg_fail(1)) SWIG_fail;
9965     {
9966         PyThreadState* __tstate = wxPyBeginAllowThreads();
9967         result = (int)((wxCalculateLayoutEvent const *)arg1)->GetFlags();
9968
9969         wxPyEndAllowThreads(__tstate);
9970         if (PyErr_Occurred()) SWIG_fail;
9971     }
9972     {
9973         resultobj = SWIG_From_int((int)(result));
9974     }
9975     return resultobj;
9976     fail:
9977     return NULL;
9978 }
9979
9980
9981 static PyObject *_wrap_CalculateLayoutEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
9982     PyObject *resultobj;
9983     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
9984     wxRect *arg2 = 0 ;
9985     wxRect temp2 ;
9986     PyObject * obj0 = 0 ;
9987     PyObject * obj1 = 0 ;
9988     char *kwnames[] = {
9989         (char *) "self",(char *) "rect", NULL
9990     };
9991
9992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
9993     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
9994     if (SWIG_arg_fail(1)) SWIG_fail;
9995     {
9996         arg2 = &temp2;
9997         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
9998     }
9999     {
10000         PyThreadState* __tstate = wxPyBeginAllowThreads();
10001         (arg1)->SetRect((wxRect const &)*arg2);
10002
10003         wxPyEndAllowThreads(__tstate);
10004         if (PyErr_Occurred()) SWIG_fail;
10005     }
10006     Py_INCREF(Py_None); resultobj = Py_None;
10007     return resultobj;
10008     fail:
10009     return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_CalculateLayoutEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10014     PyObject *resultobj;
10015     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10016     wxRect result;
10017     PyObject * obj0 = 0 ;
10018     char *kwnames[] = {
10019         (char *) "self", NULL
10020     };
10021
10022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetRect",kwnames,&obj0)) goto fail;
10023     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10024     if (SWIG_arg_fail(1)) SWIG_fail;
10025     {
10026         PyThreadState* __tstate = wxPyBeginAllowThreads();
10027         result = ((wxCalculateLayoutEvent const *)arg1)->GetRect();
10028
10029         wxPyEndAllowThreads(__tstate);
10030         if (PyErr_Occurred()) SWIG_fail;
10031     }
10032     {
10033         wxRect * resultptr;
10034         resultptr = new wxRect((wxRect &)(result));
10035         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
10036     }
10037     return resultobj;
10038     fail:
10039     return NULL;
10040 }
10041
10042
10043 static PyObject * CalculateLayoutEvent_swigregister(PyObject *, PyObject *args) {
10044     PyObject *obj;
10045     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10046     SWIG_TypeClientData(SWIGTYPE_p_wxCalculateLayoutEvent, obj);
10047     Py_INCREF(obj);
10048     return Py_BuildValue((char *)"");
10049 }
10050 static PyObject *_wrap_new_SashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10051     PyObject *resultobj;
10052     wxWindow *arg1 = (wxWindow *) 0 ;
10053     int arg2 = (int) -1 ;
10054     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10055     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10056     wxSize const &arg4_defvalue = wxDefaultSize ;
10057     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10058     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10059     wxString const &arg6_defvalue = wxPySashLayoutNameStr ;
10060     wxString *arg6 = (wxString *) &arg6_defvalue ;
10061     wxSashLayoutWindow *result;
10062     wxPoint temp3 ;
10063     wxSize temp4 ;
10064     bool temp6 = false ;
10065     PyObject * obj0 = 0 ;
10066     PyObject * obj1 = 0 ;
10067     PyObject * obj2 = 0 ;
10068     PyObject * obj3 = 0 ;
10069     PyObject * obj4 = 0 ;
10070     PyObject * obj5 = 0 ;
10071     char *kwnames[] = {
10072         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10073     };
10074
10075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashLayoutWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10076     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10077     if (SWIG_arg_fail(1)) SWIG_fail;
10078     if (obj1) {
10079         {
10080             arg2 = (int)(SWIG_As_int(obj1));
10081             if (SWIG_arg_fail(2)) SWIG_fail;
10082         }
10083     }
10084     if (obj2) {
10085         {
10086             arg3 = &temp3;
10087             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10088         }
10089     }
10090     if (obj3) {
10091         {
10092             arg4 = &temp4;
10093             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10094         }
10095     }
10096     if (obj4) {
10097         {
10098             arg5 = (long)(SWIG_As_long(obj4));
10099             if (SWIG_arg_fail(5)) SWIG_fail;
10100         }
10101     }
10102     if (obj5) {
10103         {
10104             arg6 = wxString_in_helper(obj5);
10105             if (arg6 == NULL) SWIG_fail;
10106             temp6 = true;
10107         }
10108     }
10109     {
10110         if (!wxPyCheckForApp()) SWIG_fail;
10111         PyThreadState* __tstate = wxPyBeginAllowThreads();
10112         result = (wxSashLayoutWindow *)new wxSashLayoutWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10113
10114         wxPyEndAllowThreads(__tstate);
10115         if (PyErr_Occurred()) SWIG_fail;
10116     }
10117     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10118     {
10119         if (temp6)
10120         delete arg6;
10121     }
10122     return resultobj;
10123     fail:
10124     {
10125         if (temp6)
10126         delete arg6;
10127     }
10128     return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_new_PreSashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10133     PyObject *resultobj;
10134     wxSashLayoutWindow *result;
10135     char *kwnames[] = {
10136         NULL
10137     };
10138
10139     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashLayoutWindow",kwnames)) goto fail;
10140     {
10141         if (!wxPyCheckForApp()) SWIG_fail;
10142         PyThreadState* __tstate = wxPyBeginAllowThreads();
10143         result = (wxSashLayoutWindow *)new wxSashLayoutWindow();
10144
10145         wxPyEndAllowThreads(__tstate);
10146         if (PyErr_Occurred()) SWIG_fail;
10147     }
10148     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10149     return resultobj;
10150     fail:
10151     return NULL;
10152 }
10153
10154
10155 static PyObject *_wrap_SashLayoutWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10156     PyObject *resultobj;
10157     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10158     wxWindow *arg2 = (wxWindow *) 0 ;
10159     int arg3 = (int) -1 ;
10160     wxPoint const &arg4_defvalue = wxDefaultPosition ;
10161     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10162     wxSize const &arg5_defvalue = wxDefaultSize ;
10163     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10164     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10165     wxString const &arg7_defvalue = wxPySashLayoutNameStr ;
10166     wxString *arg7 = (wxString *) &arg7_defvalue ;
10167     bool result;
10168     wxPoint temp4 ;
10169     wxSize temp5 ;
10170     bool temp7 = false ;
10171     PyObject * obj0 = 0 ;
10172     PyObject * obj1 = 0 ;
10173     PyObject * obj2 = 0 ;
10174     PyObject * obj3 = 0 ;
10175     PyObject * obj4 = 0 ;
10176     PyObject * obj5 = 0 ;
10177     PyObject * obj6 = 0 ;
10178     char *kwnames[] = {
10179         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10180     };
10181
10182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashLayoutWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10184     if (SWIG_arg_fail(1)) SWIG_fail;
10185     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10186     if (SWIG_arg_fail(2)) SWIG_fail;
10187     if (obj2) {
10188         {
10189             arg3 = (int)(SWIG_As_int(obj2));
10190             if (SWIG_arg_fail(3)) SWIG_fail;
10191         }
10192     }
10193     if (obj3) {
10194         {
10195             arg4 = &temp4;
10196             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10197         }
10198     }
10199     if (obj4) {
10200         {
10201             arg5 = &temp5;
10202             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10203         }
10204     }
10205     if (obj5) {
10206         {
10207             arg6 = (long)(SWIG_As_long(obj5));
10208             if (SWIG_arg_fail(6)) SWIG_fail;
10209         }
10210     }
10211     if (obj6) {
10212         {
10213             arg7 = wxString_in_helper(obj6);
10214             if (arg7 == NULL) SWIG_fail;
10215             temp7 = true;
10216         }
10217     }
10218     {
10219         PyThreadState* __tstate = wxPyBeginAllowThreads();
10220         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10221
10222         wxPyEndAllowThreads(__tstate);
10223         if (PyErr_Occurred()) SWIG_fail;
10224     }
10225     {
10226         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10227     }
10228     {
10229         if (temp7)
10230         delete arg7;
10231     }
10232     return resultobj;
10233     fail:
10234     {
10235         if (temp7)
10236         delete arg7;
10237     }
10238     return NULL;
10239 }
10240
10241
10242 static PyObject *_wrap_SashLayoutWindow_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10243     PyObject *resultobj;
10244     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10245     wxLayoutAlignment result;
10246     PyObject * obj0 = 0 ;
10247     char *kwnames[] = {
10248         (char *) "self", NULL
10249     };
10250
10251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetAlignment",kwnames,&obj0)) goto fail;
10252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10253     if (SWIG_arg_fail(1)) SWIG_fail;
10254     {
10255         PyThreadState* __tstate = wxPyBeginAllowThreads();
10256         result = (wxLayoutAlignment)(arg1)->GetAlignment();
10257
10258         wxPyEndAllowThreads(__tstate);
10259         if (PyErr_Occurred()) SWIG_fail;
10260     }
10261     resultobj = SWIG_From_int((result));
10262     return resultobj;
10263     fail:
10264     return NULL;
10265 }
10266
10267
10268 static PyObject *_wrap_SashLayoutWindow_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10269     PyObject *resultobj;
10270     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10271     wxLayoutOrientation result;
10272     PyObject * obj0 = 0 ;
10273     char *kwnames[] = {
10274         (char *) "self", NULL
10275     };
10276
10277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetOrientation",kwnames,&obj0)) goto fail;
10278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10279     if (SWIG_arg_fail(1)) SWIG_fail;
10280     {
10281         PyThreadState* __tstate = wxPyBeginAllowThreads();
10282         result = (wxLayoutOrientation)(arg1)->GetOrientation();
10283
10284         wxPyEndAllowThreads(__tstate);
10285         if (PyErr_Occurred()) SWIG_fail;
10286     }
10287     resultobj = SWIG_From_int((result));
10288     return resultobj;
10289     fail:
10290     return NULL;
10291 }
10292
10293
10294 static PyObject *_wrap_SashLayoutWindow_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10295     PyObject *resultobj;
10296     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10297     wxLayoutAlignment arg2 ;
10298     PyObject * obj0 = 0 ;
10299     PyObject * obj1 = 0 ;
10300     char *kwnames[] = {
10301         (char *) "self",(char *) "alignment", NULL
10302     };
10303
10304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
10305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10306     if (SWIG_arg_fail(1)) SWIG_fail;
10307     {
10308         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
10309         if (SWIG_arg_fail(2)) SWIG_fail;
10310     }
10311     {
10312         PyThreadState* __tstate = wxPyBeginAllowThreads();
10313         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
10314
10315         wxPyEndAllowThreads(__tstate);
10316         if (PyErr_Occurred()) SWIG_fail;
10317     }
10318     Py_INCREF(Py_None); resultobj = Py_None;
10319     return resultobj;
10320     fail:
10321     return NULL;
10322 }
10323
10324
10325 static PyObject *_wrap_SashLayoutWindow_SetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
10326     PyObject *resultobj;
10327     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10328     wxSize *arg2 = 0 ;
10329     wxSize temp2 ;
10330     PyObject * obj0 = 0 ;
10331     PyObject * obj1 = 0 ;
10332     char *kwnames[] = {
10333         (char *) "self",(char *) "size", NULL
10334     };
10335
10336     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetDefaultSize",kwnames,&obj0,&obj1)) goto fail;
10337     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10338     if (SWIG_arg_fail(1)) SWIG_fail;
10339     {
10340         arg2 = &temp2;
10341         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10342     }
10343     {
10344         PyThreadState* __tstate = wxPyBeginAllowThreads();
10345         (arg1)->SetDefaultSize((wxSize const &)*arg2);
10346
10347         wxPyEndAllowThreads(__tstate);
10348         if (PyErr_Occurred()) SWIG_fail;
10349     }
10350     Py_INCREF(Py_None); resultobj = Py_None;
10351     return resultobj;
10352     fail:
10353     return NULL;
10354 }
10355
10356
10357 static PyObject *_wrap_SashLayoutWindow_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10358     PyObject *resultobj;
10359     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10360     wxLayoutOrientation arg2 ;
10361     PyObject * obj0 = 0 ;
10362     PyObject * obj1 = 0 ;
10363     char *kwnames[] = {
10364         (char *) "self",(char *) "orientation", NULL
10365     };
10366
10367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
10368     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10369     if (SWIG_arg_fail(1)) SWIG_fail;
10370     {
10371         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
10372         if (SWIG_arg_fail(2)) SWIG_fail;
10373     }
10374     {
10375         PyThreadState* __tstate = wxPyBeginAllowThreads();
10376         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
10377
10378         wxPyEndAllowThreads(__tstate);
10379         if (PyErr_Occurred()) SWIG_fail;
10380     }
10381     Py_INCREF(Py_None); resultobj = Py_None;
10382     return resultobj;
10383     fail:
10384     return NULL;
10385 }
10386
10387
10388 static PyObject * SashLayoutWindow_swigregister(PyObject *, PyObject *args) {
10389     PyObject *obj;
10390     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10391     SWIG_TypeClientData(SWIGTYPE_p_wxSashLayoutWindow, obj);
10392     Py_INCREF(obj);
10393     return Py_BuildValue((char *)"");
10394 }
10395 static PyObject *_wrap_new_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10396     PyObject *resultobj;
10397     wxLayoutAlgorithm *result;
10398     char *kwnames[] = {
10399         NULL
10400     };
10401
10402     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutAlgorithm",kwnames)) goto fail;
10403     {
10404         PyThreadState* __tstate = wxPyBeginAllowThreads();
10405         result = (wxLayoutAlgorithm *)new wxLayoutAlgorithm();
10406
10407         wxPyEndAllowThreads(__tstate);
10408         if (PyErr_Occurred()) SWIG_fail;
10409     }
10410     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutAlgorithm, 1);
10411     return resultobj;
10412     fail:
10413     return NULL;
10414 }
10415
10416
10417 static PyObject *_wrap_delete_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10418     PyObject *resultobj;
10419     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10420     PyObject * obj0 = 0 ;
10421     char *kwnames[] = {
10422         (char *) "self", NULL
10423     };
10424
10425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LayoutAlgorithm",kwnames,&obj0)) goto fail;
10426     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10427     if (SWIG_arg_fail(1)) SWIG_fail;
10428     {
10429         PyThreadState* __tstate = wxPyBeginAllowThreads();
10430         delete arg1;
10431
10432         wxPyEndAllowThreads(__tstate);
10433         if (PyErr_Occurred()) SWIG_fail;
10434     }
10435     Py_INCREF(Py_None); resultobj = Py_None;
10436     return resultobj;
10437     fail:
10438     return NULL;
10439 }
10440
10441
10442 static PyObject *_wrap_LayoutAlgorithm_LayoutMDIFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10443     PyObject *resultobj;
10444     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10445     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
10446     wxRect *arg3 = (wxRect *) NULL ;
10447     bool result;
10448     PyObject * obj0 = 0 ;
10449     PyObject * obj1 = 0 ;
10450     PyObject * obj2 = 0 ;
10451     char *kwnames[] = {
10452         (char *) "self",(char *) "frame",(char *) "rect", NULL
10453     };
10454
10455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutMDIFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10457     if (SWIG_arg_fail(1)) SWIG_fail;
10458     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
10459     if (SWIG_arg_fail(2)) SWIG_fail;
10460     if (obj2) {
10461         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10462         if (SWIG_arg_fail(3)) SWIG_fail;
10463     }
10464     {
10465         PyThreadState* __tstate = wxPyBeginAllowThreads();
10466         result = (bool)(arg1)->LayoutMDIFrame(arg2,arg3);
10467
10468         wxPyEndAllowThreads(__tstate);
10469         if (PyErr_Occurred()) SWIG_fail;
10470     }
10471     {
10472         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10473     }
10474     return resultobj;
10475     fail:
10476     return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LayoutAlgorithm_LayoutFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10481     PyObject *resultobj;
10482     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10483     wxFrame *arg2 = (wxFrame *) 0 ;
10484     wxWindow *arg3 = (wxWindow *) NULL ;
10485     bool result;
10486     PyObject * obj0 = 0 ;
10487     PyObject * obj1 = 0 ;
10488     PyObject * obj2 = 0 ;
10489     char *kwnames[] = {
10490         (char *) "self",(char *) "frame",(char *) "mainWindow", NULL
10491     };
10492
10493     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10494     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10495     if (SWIG_arg_fail(1)) SWIG_fail;
10496     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10497     if (SWIG_arg_fail(2)) SWIG_fail;
10498     if (obj2) {
10499         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10500         if (SWIG_arg_fail(3)) SWIG_fail;
10501     }
10502     {
10503         PyThreadState* __tstate = wxPyBeginAllowThreads();
10504         result = (bool)(arg1)->LayoutFrame(arg2,arg3);
10505
10506         wxPyEndAllowThreads(__tstate);
10507         if (PyErr_Occurred()) SWIG_fail;
10508     }
10509     {
10510         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10511     }
10512     return resultobj;
10513     fail:
10514     return NULL;
10515 }
10516
10517
10518 static PyObject *_wrap_LayoutAlgorithm_LayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10519     PyObject *resultobj;
10520     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10521     wxWindow *arg2 = (wxWindow *) 0 ;
10522     wxWindow *arg3 = (wxWindow *) NULL ;
10523     bool result;
10524     PyObject * obj0 = 0 ;
10525     PyObject * obj1 = 0 ;
10526     PyObject * obj2 = 0 ;
10527     char *kwnames[] = {
10528         (char *) "self",(char *) "parent",(char *) "mainWindow", NULL
10529     };
10530
10531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
10532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10533     if (SWIG_arg_fail(1)) SWIG_fail;
10534     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10535     if (SWIG_arg_fail(2)) SWIG_fail;
10536     if (obj2) {
10537         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10538         if (SWIG_arg_fail(3)) SWIG_fail;
10539     }
10540     {
10541         PyThreadState* __tstate = wxPyBeginAllowThreads();
10542         result = (bool)(arg1)->LayoutWindow(arg2,arg3);
10543
10544         wxPyEndAllowThreads(__tstate);
10545         if (PyErr_Occurred()) SWIG_fail;
10546     }
10547     {
10548         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10549     }
10550     return resultobj;
10551     fail:
10552     return NULL;
10553 }
10554
10555
10556 static PyObject * LayoutAlgorithm_swigregister(PyObject *, PyObject *args) {
10557     PyObject *obj;
10558     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10559     SWIG_TypeClientData(SWIGTYPE_p_wxLayoutAlgorithm, obj);
10560     Py_INCREF(obj);
10561     return Py_BuildValue((char *)"");
10562 }
10563 static PyObject *_wrap_new_PopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10564     PyObject *resultobj;
10565     wxWindow *arg1 = (wxWindow *) 0 ;
10566     int arg2 = (int) wxBORDER_NONE ;
10567     wxPopupWindow *result;
10568     PyObject * obj0 = 0 ;
10569     PyObject * obj1 = 0 ;
10570     char *kwnames[] = {
10571         (char *) "parent",(char *) "flags", NULL
10572     };
10573
10574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupWindow",kwnames,&obj0,&obj1)) goto fail;
10575     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10576     if (SWIG_arg_fail(1)) SWIG_fail;
10577     if (obj1) {
10578         {
10579             arg2 = (int)(SWIG_As_int(obj1));
10580             if (SWIG_arg_fail(2)) SWIG_fail;
10581         }
10582     }
10583     {
10584         if (!wxPyCheckForApp()) SWIG_fail;
10585         PyThreadState* __tstate = wxPyBeginAllowThreads();
10586         result = (wxPopupWindow *)new wxPopupWindow(arg1,arg2);
10587
10588         wxPyEndAllowThreads(__tstate);
10589         if (PyErr_Occurred()) SWIG_fail;
10590     }
10591     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10592     return resultobj;
10593     fail:
10594     return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_new_PrePopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10599     PyObject *resultobj;
10600     wxPopupWindow *result;
10601     char *kwnames[] = {
10602         NULL
10603     };
10604
10605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupWindow",kwnames)) goto fail;
10606     {
10607         if (!wxPyCheckForApp()) SWIG_fail;
10608         PyThreadState* __tstate = wxPyBeginAllowThreads();
10609         result = (wxPopupWindow *)new wxPopupWindow();
10610
10611         wxPyEndAllowThreads(__tstate);
10612         if (PyErr_Occurred()) SWIG_fail;
10613     }
10614     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10615     return resultobj;
10616     fail:
10617     return NULL;
10618 }
10619
10620
10621 static PyObject *_wrap_PopupWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10622     PyObject *resultobj;
10623     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10624     wxWindow *arg2 = (wxWindow *) 0 ;
10625     int arg3 = (int) wxBORDER_NONE ;
10626     bool result;
10627     PyObject * obj0 = 0 ;
10628     PyObject * obj1 = 0 ;
10629     PyObject * obj2 = 0 ;
10630     char *kwnames[] = {
10631         (char *) "self",(char *) "parent",(char *) "flags", NULL
10632     };
10633
10634     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PopupWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10635     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10636     if (SWIG_arg_fail(1)) SWIG_fail;
10637     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10638     if (SWIG_arg_fail(2)) SWIG_fail;
10639     if (obj2) {
10640         {
10641             arg3 = (int)(SWIG_As_int(obj2));
10642             if (SWIG_arg_fail(3)) SWIG_fail;
10643         }
10644     }
10645     {
10646         PyThreadState* __tstate = wxPyBeginAllowThreads();
10647         result = (bool)(arg1)->Create(arg2,arg3);
10648
10649         wxPyEndAllowThreads(__tstate);
10650         if (PyErr_Occurred()) SWIG_fail;
10651     }
10652     {
10653         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10654     }
10655     return resultobj;
10656     fail:
10657     return NULL;
10658 }
10659
10660
10661 static PyObject *_wrap_PopupWindow_Position(PyObject *, PyObject *args, PyObject *kwargs) {
10662     PyObject *resultobj;
10663     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10664     wxPoint *arg2 = 0 ;
10665     wxSize *arg3 = 0 ;
10666     wxPoint temp2 ;
10667     wxSize temp3 ;
10668     PyObject * obj0 = 0 ;
10669     PyObject * obj1 = 0 ;
10670     PyObject * obj2 = 0 ;
10671     char *kwnames[] = {
10672         (char *) "self",(char *) "ptOrigin",(char *) "size", NULL
10673     };
10674
10675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupWindow_Position",kwnames,&obj0,&obj1,&obj2)) goto fail;
10676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10677     if (SWIG_arg_fail(1)) SWIG_fail;
10678     {
10679         arg2 = &temp2;
10680         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10681     }
10682     {
10683         arg3 = &temp3;
10684         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
10685     }
10686     {
10687         PyThreadState* __tstate = wxPyBeginAllowThreads();
10688         (arg1)->Position((wxPoint const &)*arg2,(wxSize const &)*arg3);
10689
10690         wxPyEndAllowThreads(__tstate);
10691         if (PyErr_Occurred()) SWIG_fail;
10692     }
10693     Py_INCREF(Py_None); resultobj = Py_None;
10694     return resultobj;
10695     fail:
10696     return NULL;
10697 }
10698
10699
10700 static PyObject * PopupWindow_swigregister(PyObject *, PyObject *args) {
10701     PyObject *obj;
10702     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10703     SWIG_TypeClientData(SWIGTYPE_p_wxPopupWindow, obj);
10704     Py_INCREF(obj);
10705     return Py_BuildValue((char *)"");
10706 }
10707 static PyObject *_wrap_new_PopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10708     PyObject *resultobj;
10709     wxWindow *arg1 = (wxWindow *) 0 ;
10710     int arg2 = (int) wxBORDER_NONE ;
10711     wxPyPopupTransientWindow *result;
10712     PyObject * obj0 = 0 ;
10713     PyObject * obj1 = 0 ;
10714     char *kwnames[] = {
10715         (char *) "parent",(char *) "style", NULL
10716     };
10717
10718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupTransientWindow",kwnames,&obj0,&obj1)) goto fail;
10719     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10720     if (SWIG_arg_fail(1)) SWIG_fail;
10721     if (obj1) {
10722         {
10723             arg2 = (int)(SWIG_As_int(obj1));
10724             if (SWIG_arg_fail(2)) SWIG_fail;
10725         }
10726     }
10727     {
10728         if (!wxPyCheckForApp()) SWIG_fail;
10729         PyThreadState* __tstate = wxPyBeginAllowThreads();
10730         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow(arg1,arg2);
10731
10732         wxPyEndAllowThreads(__tstate);
10733         if (PyErr_Occurred()) SWIG_fail;
10734     }
10735     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10736     return resultobj;
10737     fail:
10738     return NULL;
10739 }
10740
10741
10742 static PyObject *_wrap_new_PrePopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10743     PyObject *resultobj;
10744     wxPyPopupTransientWindow *result;
10745     char *kwnames[] = {
10746         NULL
10747     };
10748
10749     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupTransientWindow",kwnames)) goto fail;
10750     {
10751         if (!wxPyCheckForApp()) SWIG_fail;
10752         PyThreadState* __tstate = wxPyBeginAllowThreads();
10753         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow();
10754
10755         wxPyEndAllowThreads(__tstate);
10756         if (PyErr_Occurred()) SWIG_fail;
10757     }
10758     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10759     return resultobj;
10760     fail:
10761     return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_PopupTransientWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10766     PyObject *resultobj;
10767     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10768     PyObject *arg2 = (PyObject *) 0 ;
10769     PyObject *arg3 = (PyObject *) 0 ;
10770     PyObject * obj0 = 0 ;
10771     PyObject * obj1 = 0 ;
10772     PyObject * obj2 = 0 ;
10773     char *kwnames[] = {
10774         (char *) "self",(char *) "self",(char *) "_class", NULL
10775     };
10776
10777     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupTransientWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10778     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10779     if (SWIG_arg_fail(1)) SWIG_fail;
10780     arg2 = obj1;
10781     arg3 = obj2;
10782     {
10783         PyThreadState* __tstate = wxPyBeginAllowThreads();
10784         (arg1)->_setCallbackInfo(arg2,arg3);
10785
10786         wxPyEndAllowThreads(__tstate);
10787         if (PyErr_Occurred()) SWIG_fail;
10788     }
10789     Py_INCREF(Py_None); resultobj = Py_None;
10790     return resultobj;
10791     fail:
10792     return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_PopupTransientWindow_Popup(PyObject *, PyObject *args, PyObject *kwargs) {
10797     PyObject *resultobj;
10798     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10799     wxWindow *arg2 = (wxWindow *) NULL ;
10800     PyObject * obj0 = 0 ;
10801     PyObject * obj1 = 0 ;
10802     char *kwnames[] = {
10803         (char *) "self",(char *) "focus", NULL
10804     };
10805
10806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PopupTransientWindow_Popup",kwnames,&obj0,&obj1)) goto fail;
10807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10808     if (SWIG_arg_fail(1)) SWIG_fail;
10809     if (obj1) {
10810         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10811         if (SWIG_arg_fail(2)) SWIG_fail;
10812     }
10813     {
10814         PyThreadState* __tstate = wxPyBeginAllowThreads();
10815         (arg1)->Popup(arg2);
10816
10817         wxPyEndAllowThreads(__tstate);
10818         if (PyErr_Occurred()) SWIG_fail;
10819     }
10820     Py_INCREF(Py_None); resultobj = Py_None;
10821     return resultobj;
10822     fail:
10823     return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_PopupTransientWindow_Dismiss(PyObject *, PyObject *args, PyObject *kwargs) {
10828     PyObject *resultobj;
10829     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10830     PyObject * obj0 = 0 ;
10831     char *kwnames[] = {
10832         (char *) "self", NULL
10833     };
10834
10835     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PopupTransientWindow_Dismiss",kwnames,&obj0)) goto fail;
10836     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10837     if (SWIG_arg_fail(1)) SWIG_fail;
10838     {
10839         PyThreadState* __tstate = wxPyBeginAllowThreads();
10840         (arg1)->Dismiss();
10841
10842         wxPyEndAllowThreads(__tstate);
10843         if (PyErr_Occurred()) SWIG_fail;
10844     }
10845     Py_INCREF(Py_None); resultobj = Py_None;
10846     return resultobj;
10847     fail:
10848     return NULL;
10849 }
10850
10851
10852 static PyObject * PopupTransientWindow_swigregister(PyObject *, PyObject *args) {
10853     PyObject *obj;
10854     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10855     SWIG_TypeClientData(SWIGTYPE_p_wxPyPopupTransientWindow, obj);
10856     Py_INCREF(obj);
10857     return Py_BuildValue((char *)"");
10858 }
10859 static PyObject *_wrap_new_TipWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10860     PyObject *resultobj;
10861     wxWindow *arg1 = (wxWindow *) 0 ;
10862     wxString *arg2 = 0 ;
10863     int arg3 = (int) 100 ;
10864     wxRect *arg4 = (wxRect *) NULL ;
10865     wxTipWindow *result;
10866     bool temp2 = false ;
10867     PyObject * obj0 = 0 ;
10868     PyObject * obj1 = 0 ;
10869     PyObject * obj2 = 0 ;
10870     PyObject * obj3 = 0 ;
10871     char *kwnames[] = {
10872         (char *) "parent",(char *) "text",(char *) "maxLength",(char *) "rectBound", NULL
10873     };
10874
10875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_TipWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10876     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10877     if (SWIG_arg_fail(1)) SWIG_fail;
10878     {
10879         arg2 = wxString_in_helper(obj1);
10880         if (arg2 == NULL) SWIG_fail;
10881         temp2 = true;
10882     }
10883     if (obj2) {
10884         {
10885             arg3 = (int)(SWIG_As_int(obj2));
10886             if (SWIG_arg_fail(3)) SWIG_fail;
10887         }
10888     }
10889     if (obj3) {
10890         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10891         if (SWIG_arg_fail(4)) SWIG_fail;
10892     }
10893     {
10894         if (!wxPyCheckForApp()) SWIG_fail;
10895         PyThreadState* __tstate = wxPyBeginAllowThreads();
10896         result = (wxTipWindow *)new_wxTipWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10897
10898         wxPyEndAllowThreads(__tstate);
10899         if (PyErr_Occurred()) SWIG_fail;
10900     }
10901     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipWindow, 1);
10902     {
10903         if (temp2)
10904         delete arg2;
10905     }
10906     return resultobj;
10907     fail:
10908     {
10909         if (temp2)
10910         delete arg2;
10911     }
10912     return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_TipWindow_SetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
10917     PyObject *resultobj;
10918     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10919     wxRect *arg2 = 0 ;
10920     wxRect temp2 ;
10921     PyObject * obj0 = 0 ;
10922     PyObject * obj1 = 0 ;
10923     char *kwnames[] = {
10924         (char *) "self",(char *) "rectBound", NULL
10925     };
10926
10927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipWindow_SetBoundingRect",kwnames,&obj0,&obj1)) goto fail;
10928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10929     if (SWIG_arg_fail(1)) SWIG_fail;
10930     {
10931         arg2 = &temp2;
10932         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10933     }
10934     {
10935         PyThreadState* __tstate = wxPyBeginAllowThreads();
10936         (arg1)->SetBoundingRect((wxRect const &)*arg2);
10937
10938         wxPyEndAllowThreads(__tstate);
10939         if (PyErr_Occurred()) SWIG_fail;
10940     }
10941     Py_INCREF(Py_None); resultobj = Py_None;
10942     return resultobj;
10943     fail:
10944     return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_TipWindow_Close(PyObject *, PyObject *args, PyObject *kwargs) {
10949     PyObject *resultobj;
10950     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10951     PyObject * obj0 = 0 ;
10952     char *kwnames[] = {
10953         (char *) "self", NULL
10954     };
10955
10956     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipWindow_Close",kwnames,&obj0)) goto fail;
10957     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10958     if (SWIG_arg_fail(1)) SWIG_fail;
10959     {
10960         PyThreadState* __tstate = wxPyBeginAllowThreads();
10961         (arg1)->Close();
10962
10963         wxPyEndAllowThreads(__tstate);
10964         if (PyErr_Occurred()) SWIG_fail;
10965     }
10966     Py_INCREF(Py_None); resultobj = Py_None;
10967     return resultobj;
10968     fail:
10969     return NULL;
10970 }
10971
10972
10973 static PyObject * TipWindow_swigregister(PyObject *, PyObject *args) {
10974     PyObject *obj;
10975     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10976     SWIG_TypeClientData(SWIGTYPE_p_wxTipWindow, obj);
10977     Py_INCREF(obj);
10978     return Py_BuildValue((char *)"");
10979 }
10980 static PyObject *_wrap_new_VScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10981     PyObject *resultobj;
10982     wxWindow *arg1 = (wxWindow *) 0 ;
10983     int arg2 = (int) wxID_ANY ;
10984     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10985     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10986     wxSize const &arg4_defvalue = wxDefaultSize ;
10987     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10988     long arg5 = (long) 0 ;
10989     wxString const &arg6_defvalue = wxPyPanelNameStr ;
10990     wxString *arg6 = (wxString *) &arg6_defvalue ;
10991     wxPyVScrolledWindow *result;
10992     wxPoint temp3 ;
10993     wxSize temp4 ;
10994     bool temp6 = false ;
10995     PyObject * obj0 = 0 ;
10996     PyObject * obj1 = 0 ;
10997     PyObject * obj2 = 0 ;
10998     PyObject * obj3 = 0 ;
10999     PyObject * obj4 = 0 ;
11000     PyObject * obj5 = 0 ;
11001     char *kwnames[] = {
11002         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11003     };
11004
11005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11007     if (SWIG_arg_fail(1)) SWIG_fail;
11008     if (obj1) {
11009         {
11010             arg2 = (int)(SWIG_As_int(obj1));
11011             if (SWIG_arg_fail(2)) SWIG_fail;
11012         }
11013     }
11014     if (obj2) {
11015         {
11016             arg3 = &temp3;
11017             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11018         }
11019     }
11020     if (obj3) {
11021         {
11022             arg4 = &temp4;
11023             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11024         }
11025     }
11026     if (obj4) {
11027         {
11028             arg5 = (long)(SWIG_As_long(obj4));
11029             if (SWIG_arg_fail(5)) SWIG_fail;
11030         }
11031     }
11032     if (obj5) {
11033         {
11034             arg6 = wxString_in_helper(obj5);
11035             if (arg6 == NULL) SWIG_fail;
11036             temp6 = true;
11037         }
11038     }
11039     {
11040         if (!wxPyCheckForApp()) SWIG_fail;
11041         PyThreadState* __tstate = wxPyBeginAllowThreads();
11042         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11043
11044         wxPyEndAllowThreads(__tstate);
11045         if (PyErr_Occurred()) SWIG_fail;
11046     }
11047     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11048     {
11049         if (temp6)
11050         delete arg6;
11051     }
11052     return resultobj;
11053     fail:
11054     {
11055         if (temp6)
11056         delete arg6;
11057     }
11058     return NULL;
11059 }
11060
11061
11062 static PyObject *_wrap_new_PreVScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
11063     PyObject *resultobj;
11064     wxPyVScrolledWindow *result;
11065     char *kwnames[] = {
11066         NULL
11067     };
11068
11069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVScrolledWindow",kwnames)) goto fail;
11070     {
11071         if (!wxPyCheckForApp()) SWIG_fail;
11072         PyThreadState* __tstate = wxPyBeginAllowThreads();
11073         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow();
11074
11075         wxPyEndAllowThreads(__tstate);
11076         if (PyErr_Occurred()) SWIG_fail;
11077     }
11078     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11079     return resultobj;
11080     fail:
11081     return NULL;
11082 }
11083
11084
11085 static PyObject *_wrap_VScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11086     PyObject *resultobj;
11087     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11088     PyObject *arg2 = (PyObject *) 0 ;
11089     PyObject *arg3 = (PyObject *) 0 ;
11090     PyObject * obj0 = 0 ;
11091     PyObject * obj1 = 0 ;
11092     PyObject * obj2 = 0 ;
11093     char *kwnames[] = {
11094         (char *) "self",(char *) "self",(char *) "_class", NULL
11095     };
11096
11097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11099     if (SWIG_arg_fail(1)) SWIG_fail;
11100     arg2 = obj1;
11101     arg3 = obj2;
11102     {
11103         PyThreadState* __tstate = wxPyBeginAllowThreads();
11104         (arg1)->_setCallbackInfo(arg2,arg3);
11105
11106         wxPyEndAllowThreads(__tstate);
11107         if (PyErr_Occurred()) SWIG_fail;
11108     }
11109     Py_INCREF(Py_None); resultobj = Py_None;
11110     return resultobj;
11111     fail:
11112     return NULL;
11113 }
11114
11115
11116 static PyObject *_wrap_VScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11117     PyObject *resultobj;
11118     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11119     wxWindow *arg2 = (wxWindow *) 0 ;
11120     int arg3 = (int) wxID_ANY ;
11121     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11122     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11123     wxSize const &arg5_defvalue = wxDefaultSize ;
11124     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11125     long arg6 = (long) 0 ;
11126     wxString const &arg7_defvalue = wxPyPanelNameStr ;
11127     wxString *arg7 = (wxString *) &arg7_defvalue ;
11128     bool result;
11129     wxPoint temp4 ;
11130     wxSize temp5 ;
11131     bool temp7 = false ;
11132     PyObject * obj0 = 0 ;
11133     PyObject * obj1 = 0 ;
11134     PyObject * obj2 = 0 ;
11135     PyObject * obj3 = 0 ;
11136     PyObject * obj4 = 0 ;
11137     PyObject * obj5 = 0 ;
11138     PyObject * obj6 = 0 ;
11139     char *kwnames[] = {
11140         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11141     };
11142
11143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11145     if (SWIG_arg_fail(1)) SWIG_fail;
11146     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11147     if (SWIG_arg_fail(2)) SWIG_fail;
11148     if (obj2) {
11149         {
11150             arg3 = (int)(SWIG_As_int(obj2));
11151             if (SWIG_arg_fail(3)) SWIG_fail;
11152         }
11153     }
11154     if (obj3) {
11155         {
11156             arg4 = &temp4;
11157             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11158         }
11159     }
11160     if (obj4) {
11161         {
11162             arg5 = &temp5;
11163             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11164         }
11165     }
11166     if (obj5) {
11167         {
11168             arg6 = (long)(SWIG_As_long(obj5));
11169             if (SWIG_arg_fail(6)) SWIG_fail;
11170         }
11171     }
11172     if (obj6) {
11173         {
11174             arg7 = wxString_in_helper(obj6);
11175             if (arg7 == NULL) SWIG_fail;
11176             temp7 = true;
11177         }
11178     }
11179     {
11180         PyThreadState* __tstate = wxPyBeginAllowThreads();
11181         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11182
11183         wxPyEndAllowThreads(__tstate);
11184         if (PyErr_Occurred()) SWIG_fail;
11185     }
11186     {
11187         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11188     }
11189     {
11190         if (temp7)
11191         delete arg7;
11192     }
11193     return resultobj;
11194     fail:
11195     {
11196         if (temp7)
11197         delete arg7;
11198     }
11199     return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_VScrolledWindow_SetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11204     PyObject *resultobj;
11205     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11206     size_t arg2 ;
11207     PyObject * obj0 = 0 ;
11208     PyObject * obj1 = 0 ;
11209     char *kwnames[] = {
11210         (char *) "self",(char *) "count", NULL
11211     };
11212
11213     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_SetLineCount",kwnames,&obj0,&obj1)) goto fail;
11214     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11215     if (SWIG_arg_fail(1)) SWIG_fail;
11216     {
11217         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11218         if (SWIG_arg_fail(2)) SWIG_fail;
11219     }
11220     {
11221         PyThreadState* __tstate = wxPyBeginAllowThreads();
11222         (arg1)->SetLineCount(arg2);
11223
11224         wxPyEndAllowThreads(__tstate);
11225         if (PyErr_Occurred()) SWIG_fail;
11226     }
11227     Py_INCREF(Py_None); resultobj = Py_None;
11228     return resultobj;
11229     fail:
11230     return NULL;
11231 }
11232
11233
11234 static PyObject *_wrap_VScrolledWindow_ScrollToLine(PyObject *, PyObject *args, PyObject *kwargs) {
11235     PyObject *resultobj;
11236     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11237     size_t arg2 ;
11238     bool result;
11239     PyObject * obj0 = 0 ;
11240     PyObject * obj1 = 0 ;
11241     char *kwnames[] = {
11242         (char *) "self",(char *) "line", NULL
11243     };
11244
11245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollToLine",kwnames,&obj0,&obj1)) goto fail;
11246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11247     if (SWIG_arg_fail(1)) SWIG_fail;
11248     {
11249         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11250         if (SWIG_arg_fail(2)) SWIG_fail;
11251     }
11252     {
11253         PyThreadState* __tstate = wxPyBeginAllowThreads();
11254         result = (bool)(arg1)->ScrollToLine(arg2);
11255
11256         wxPyEndAllowThreads(__tstate);
11257         if (PyErr_Occurred()) SWIG_fail;
11258     }
11259     {
11260         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11261     }
11262     return resultobj;
11263     fail:
11264     return NULL;
11265 }
11266
11267
11268 static PyObject *_wrap_VScrolledWindow_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
11269     PyObject *resultobj;
11270     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11271     int arg2 ;
11272     bool result;
11273     PyObject * obj0 = 0 ;
11274     PyObject * obj1 = 0 ;
11275     char *kwnames[] = {
11276         (char *) "self",(char *) "lines", NULL
11277     };
11278
11279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
11280     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11281     if (SWIG_arg_fail(1)) SWIG_fail;
11282     {
11283         arg2 = (int)(SWIG_As_int(obj1));
11284         if (SWIG_arg_fail(2)) SWIG_fail;
11285     }
11286     {
11287         PyThreadState* __tstate = wxPyBeginAllowThreads();
11288         result = (bool)(arg1)->ScrollLines(arg2);
11289
11290         wxPyEndAllowThreads(__tstate);
11291         if (PyErr_Occurred()) SWIG_fail;
11292     }
11293     {
11294         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11295     }
11296     return resultobj;
11297     fail:
11298     return NULL;
11299 }
11300
11301
11302 static PyObject *_wrap_VScrolledWindow_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
11303     PyObject *resultobj;
11304     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11305     int arg2 ;
11306     bool result;
11307     PyObject * obj0 = 0 ;
11308     PyObject * obj1 = 0 ;
11309     char *kwnames[] = {
11310         (char *) "self",(char *) "pages", NULL
11311     };
11312
11313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
11314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11315     if (SWIG_arg_fail(1)) SWIG_fail;
11316     {
11317         arg2 = (int)(SWIG_As_int(obj1));
11318         if (SWIG_arg_fail(2)) SWIG_fail;
11319     }
11320     {
11321         PyThreadState* __tstate = wxPyBeginAllowThreads();
11322         result = (bool)(arg1)->ScrollPages(arg2);
11323
11324         wxPyEndAllowThreads(__tstate);
11325         if (PyErr_Occurred()) SWIG_fail;
11326     }
11327     {
11328         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11329     }
11330     return resultobj;
11331     fail:
11332     return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_VScrolledWindow_RefreshLine(PyObject *, PyObject *args, PyObject *kwargs) {
11337     PyObject *resultobj;
11338     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11339     size_t arg2 ;
11340     PyObject * obj0 = 0 ;
11341     PyObject * obj1 = 0 ;
11342     char *kwnames[] = {
11343         (char *) "self",(char *) "line", NULL
11344     };
11345
11346     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_RefreshLine",kwnames,&obj0,&obj1)) goto fail;
11347     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11348     if (SWIG_arg_fail(1)) SWIG_fail;
11349     {
11350         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11351         if (SWIG_arg_fail(2)) SWIG_fail;
11352     }
11353     {
11354         PyThreadState* __tstate = wxPyBeginAllowThreads();
11355         (arg1)->RefreshLine(arg2);
11356
11357         wxPyEndAllowThreads(__tstate);
11358         if (PyErr_Occurred()) SWIG_fail;
11359     }
11360     Py_INCREF(Py_None); resultobj = Py_None;
11361     return resultobj;
11362     fail:
11363     return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_VScrolledWindow_RefreshLines(PyObject *, PyObject *args, PyObject *kwargs) {
11368     PyObject *resultobj;
11369     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11370     size_t arg2 ;
11371     size_t arg3 ;
11372     PyObject * obj0 = 0 ;
11373     PyObject * obj1 = 0 ;
11374     PyObject * obj2 = 0 ;
11375     char *kwnames[] = {
11376         (char *) "self",(char *) "from",(char *) "to", NULL
11377     };
11378
11379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_RefreshLines",kwnames,&obj0,&obj1,&obj2)) goto fail;
11380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11381     if (SWIG_arg_fail(1)) SWIG_fail;
11382     {
11383         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11384         if (SWIG_arg_fail(2)) SWIG_fail;
11385     }
11386     {
11387         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11388         if (SWIG_arg_fail(3)) SWIG_fail;
11389     }
11390     {
11391         PyThreadState* __tstate = wxPyBeginAllowThreads();
11392         (arg1)->RefreshLines(arg2,arg3);
11393
11394         wxPyEndAllowThreads(__tstate);
11395         if (PyErr_Occurred()) SWIG_fail;
11396     }
11397     Py_INCREF(Py_None); resultobj = Py_None;
11398     return resultobj;
11399     fail:
11400     return NULL;
11401 }
11402
11403
11404 static PyObject *_wrap_VScrolledWindow_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
11405     PyObject *resultobj;
11406     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11407     int arg2 ;
11408     int arg3 ;
11409     int result;
11410     PyObject * obj0 = 0 ;
11411     PyObject * obj1 = 0 ;
11412     PyObject * obj2 = 0 ;
11413     char *kwnames[] = {
11414         (char *) "self",(char *) "x",(char *) "y", NULL
11415     };
11416
11417     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
11418     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11419     if (SWIG_arg_fail(1)) SWIG_fail;
11420     {
11421         arg2 = (int)(SWIG_As_int(obj1));
11422         if (SWIG_arg_fail(2)) SWIG_fail;
11423     }
11424     {
11425         arg3 = (int)(SWIG_As_int(obj2));
11426         if (SWIG_arg_fail(3)) SWIG_fail;
11427     }
11428     {
11429         PyThreadState* __tstate = wxPyBeginAllowThreads();
11430         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest(arg2,arg3);
11431
11432         wxPyEndAllowThreads(__tstate);
11433         if (PyErr_Occurred()) SWIG_fail;
11434     }
11435     {
11436         resultobj = SWIG_From_int((int)(result));
11437     }
11438     return resultobj;
11439     fail:
11440     return NULL;
11441 }
11442
11443
11444 static PyObject *_wrap_VScrolledWindow_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11445     PyObject *resultobj;
11446     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11447     wxPoint *arg2 = 0 ;
11448     int result;
11449     wxPoint temp2 ;
11450     PyObject * obj0 = 0 ;
11451     PyObject * obj1 = 0 ;
11452     char *kwnames[] = {
11453         (char *) "self",(char *) "pt", NULL
11454     };
11455
11456     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_HitTest",kwnames,&obj0,&obj1)) goto fail;
11457     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11458     if (SWIG_arg_fail(1)) SWIG_fail;
11459     {
11460         arg2 = &temp2;
11461         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11462     }
11463     {
11464         PyThreadState* __tstate = wxPyBeginAllowThreads();
11465         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
11466
11467         wxPyEndAllowThreads(__tstate);
11468         if (PyErr_Occurred()) SWIG_fail;
11469     }
11470     {
11471         resultobj = SWIG_From_int((int)(result));
11472     }
11473     return resultobj;
11474     fail:
11475     return NULL;
11476 }
11477
11478
11479 static PyObject *_wrap_VScrolledWindow_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
11480     PyObject *resultobj;
11481     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11482     PyObject * obj0 = 0 ;
11483     char *kwnames[] = {
11484         (char *) "self", NULL
11485     };
11486
11487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_RefreshAll",kwnames,&obj0)) goto fail;
11488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11489     if (SWIG_arg_fail(1)) SWIG_fail;
11490     {
11491         PyThreadState* __tstate = wxPyBeginAllowThreads();
11492         (arg1)->RefreshAll();
11493
11494         wxPyEndAllowThreads(__tstate);
11495         if (PyErr_Occurred()) SWIG_fail;
11496     }
11497     Py_INCREF(Py_None); resultobj = Py_None;
11498     return resultobj;
11499     fail:
11500     return NULL;
11501 }
11502
11503
11504 static PyObject *_wrap_VScrolledWindow_GetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11505     PyObject *resultobj;
11506     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11507     size_t result;
11508     PyObject * obj0 = 0 ;
11509     char *kwnames[] = {
11510         (char *) "self", NULL
11511     };
11512
11513     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLineCount",kwnames,&obj0)) goto fail;
11514     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11515     if (SWIG_arg_fail(1)) SWIG_fail;
11516     {
11517         PyThreadState* __tstate = wxPyBeginAllowThreads();
11518         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLineCount();
11519
11520         wxPyEndAllowThreads(__tstate);
11521         if (PyErr_Occurred()) SWIG_fail;
11522     }
11523     {
11524         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11525     }
11526     return resultobj;
11527     fail:
11528     return NULL;
11529 }
11530
11531
11532 static PyObject *_wrap_VScrolledWindow_GetFirstVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11533     PyObject *resultobj;
11534     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11535     size_t result;
11536     PyObject * obj0 = 0 ;
11537     char *kwnames[] = {
11538         (char *) "self", NULL
11539     };
11540
11541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetFirstVisibleLine",kwnames,&obj0)) goto fail;
11542     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11543     if (SWIG_arg_fail(1)) SWIG_fail;
11544     {
11545         PyThreadState* __tstate = wxPyBeginAllowThreads();
11546         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetFirstVisibleLine();
11547
11548         wxPyEndAllowThreads(__tstate);
11549         if (PyErr_Occurred()) SWIG_fail;
11550     }
11551     {
11552         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11553     }
11554     return resultobj;
11555     fail:
11556     return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_VScrolledWindow_GetLastVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11561     PyObject *resultobj;
11562     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11563     size_t result;
11564     PyObject * obj0 = 0 ;
11565     char *kwnames[] = {
11566         (char *) "self", NULL
11567     };
11568
11569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLastVisibleLine",kwnames,&obj0)) goto fail;
11570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11571     if (SWIG_arg_fail(1)) SWIG_fail;
11572     {
11573         PyThreadState* __tstate = wxPyBeginAllowThreads();
11574         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLastVisibleLine();
11575
11576         wxPyEndAllowThreads(__tstate);
11577         if (PyErr_Occurred()) SWIG_fail;
11578     }
11579     {
11580         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11581     }
11582     return resultobj;
11583     fail:
11584     return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_VScrolledWindow_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11589     PyObject *resultobj;
11590     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11591     size_t arg2 ;
11592     bool result;
11593     PyObject * obj0 = 0 ;
11594     PyObject * obj1 = 0 ;
11595     char *kwnames[] = {
11596         (char *) "self",(char *) "line", NULL
11597     };
11598
11599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_IsVisible",kwnames,&obj0,&obj1)) goto fail;
11600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11601     if (SWIG_arg_fail(1)) SWIG_fail;
11602     {
11603         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11604         if (SWIG_arg_fail(2)) SWIG_fail;
11605     }
11606     {
11607         PyThreadState* __tstate = wxPyBeginAllowThreads();
11608         result = (bool)((wxPyVScrolledWindow const *)arg1)->IsVisible(arg2);
11609
11610         wxPyEndAllowThreads(__tstate);
11611         if (PyErr_Occurred()) SWIG_fail;
11612     }
11613     {
11614         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11615     }
11616     return resultobj;
11617     fail:
11618     return NULL;
11619 }
11620
11621
11622 static PyObject * VScrolledWindow_swigregister(PyObject *, PyObject *args) {
11623     PyObject *obj;
11624     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11625     SWIG_TypeClientData(SWIGTYPE_p_wxPyVScrolledWindow, obj);
11626     Py_INCREF(obj);
11627     return Py_BuildValue((char *)"");
11628 }
11629 static int _wrap_VListBoxNameStr_set(PyObject *) {
11630     PyErr_SetString(PyExc_TypeError,"Variable VListBoxNameStr is read-only.");
11631     return 1;
11632 }
11633
11634
11635 static PyObject *_wrap_VListBoxNameStr_get(void) {
11636     PyObject *pyobj;
11637
11638     {
11639 #if wxUSE_UNICODE
11640         pyobj = PyUnicode_FromWideChar((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11641 #else
11642         pyobj = PyString_FromStringAndSize((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11643 #endif
11644     }
11645     return pyobj;
11646 }
11647
11648
11649 static PyObject *_wrap_new_VListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11650     PyObject *resultobj;
11651     wxWindow *arg1 = (wxWindow *) 0 ;
11652     int arg2 = (int) wxID_ANY ;
11653     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11654     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11655     wxSize const &arg4_defvalue = wxDefaultSize ;
11656     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11657     long arg5 = (long) 0 ;
11658     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
11659     wxString *arg6 = (wxString *) &arg6_defvalue ;
11660     wxPyVListBox *result;
11661     wxPoint temp3 ;
11662     wxSize temp4 ;
11663     bool temp6 = false ;
11664     PyObject * obj0 = 0 ;
11665     PyObject * obj1 = 0 ;
11666     PyObject * obj2 = 0 ;
11667     PyObject * obj3 = 0 ;
11668     PyObject * obj4 = 0 ;
11669     PyObject * obj5 = 0 ;
11670     char *kwnames[] = {
11671         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11672     };
11673
11674     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11675     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11676     if (SWIG_arg_fail(1)) SWIG_fail;
11677     if (obj1) {
11678         {
11679             arg2 = (int)(SWIG_As_int(obj1));
11680             if (SWIG_arg_fail(2)) SWIG_fail;
11681         }
11682     }
11683     if (obj2) {
11684         {
11685             arg3 = &temp3;
11686             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11687         }
11688     }
11689     if (obj3) {
11690         {
11691             arg4 = &temp4;
11692             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11693         }
11694     }
11695     if (obj4) {
11696         {
11697             arg5 = (long)(SWIG_As_long(obj4));
11698             if (SWIG_arg_fail(5)) SWIG_fail;
11699         }
11700     }
11701     if (obj5) {
11702         {
11703             arg6 = wxString_in_helper(obj5);
11704             if (arg6 == NULL) SWIG_fail;
11705             temp6 = true;
11706         }
11707     }
11708     {
11709         if (!wxPyCheckForApp()) SWIG_fail;
11710         PyThreadState* __tstate = wxPyBeginAllowThreads();
11711         result = (wxPyVListBox *)new wxPyVListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11712
11713         wxPyEndAllowThreads(__tstate);
11714         if (PyErr_Occurred()) SWIG_fail;
11715     }
11716     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11717     {
11718         if (temp6)
11719         delete arg6;
11720     }
11721     return resultobj;
11722     fail:
11723     {
11724         if (temp6)
11725         delete arg6;
11726     }
11727     return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_new_PreVListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11732     PyObject *resultobj;
11733     wxPyVListBox *result;
11734     char *kwnames[] = {
11735         NULL
11736     };
11737
11738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVListBox",kwnames)) goto fail;
11739     {
11740         if (!wxPyCheckForApp()) SWIG_fail;
11741         PyThreadState* __tstate = wxPyBeginAllowThreads();
11742         result = (wxPyVListBox *)new wxPyVListBox();
11743
11744         wxPyEndAllowThreads(__tstate);
11745         if (PyErr_Occurred()) SWIG_fail;
11746     }
11747     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11748     return resultobj;
11749     fail:
11750     return NULL;
11751 }
11752
11753
11754 static PyObject *_wrap_VListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11755     PyObject *resultobj;
11756     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11757     PyObject *arg2 = (PyObject *) 0 ;
11758     PyObject *arg3 = (PyObject *) 0 ;
11759     PyObject * obj0 = 0 ;
11760     PyObject * obj1 = 0 ;
11761     PyObject * obj2 = 0 ;
11762     char *kwnames[] = {
11763         (char *) "self",(char *) "self",(char *) "_class", NULL
11764     };
11765
11766     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11767     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11768     if (SWIG_arg_fail(1)) SWIG_fail;
11769     arg2 = obj1;
11770     arg3 = obj2;
11771     {
11772         PyThreadState* __tstate = wxPyBeginAllowThreads();
11773         (arg1)->_setCallbackInfo(arg2,arg3);
11774
11775         wxPyEndAllowThreads(__tstate);
11776         if (PyErr_Occurred()) SWIG_fail;
11777     }
11778     Py_INCREF(Py_None); resultobj = Py_None;
11779     return resultobj;
11780     fail:
11781     return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_VListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11786     PyObject *resultobj;
11787     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11788     wxWindow *arg2 = (wxWindow *) 0 ;
11789     int arg3 = (int) wxID_ANY ;
11790     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11791     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11792     wxSize const &arg5_defvalue = wxDefaultSize ;
11793     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11794     long arg6 = (long) 0 ;
11795     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
11796     wxString *arg7 = (wxString *) &arg7_defvalue ;
11797     bool result;
11798     wxPoint temp4 ;
11799     wxSize temp5 ;
11800     bool temp7 = false ;
11801     PyObject * obj0 = 0 ;
11802     PyObject * obj1 = 0 ;
11803     PyObject * obj2 = 0 ;
11804     PyObject * obj3 = 0 ;
11805     PyObject * obj4 = 0 ;
11806     PyObject * obj5 = 0 ;
11807     PyObject * obj6 = 0 ;
11808     char *kwnames[] = {
11809         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11810     };
11811
11812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11813     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11814     if (SWIG_arg_fail(1)) SWIG_fail;
11815     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11816     if (SWIG_arg_fail(2)) SWIG_fail;
11817     if (obj2) {
11818         {
11819             arg3 = (int)(SWIG_As_int(obj2));
11820             if (SWIG_arg_fail(3)) SWIG_fail;
11821         }
11822     }
11823     if (obj3) {
11824         {
11825             arg4 = &temp4;
11826             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11827         }
11828     }
11829     if (obj4) {
11830         {
11831             arg5 = &temp5;
11832             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11833         }
11834     }
11835     if (obj5) {
11836         {
11837             arg6 = (long)(SWIG_As_long(obj5));
11838             if (SWIG_arg_fail(6)) SWIG_fail;
11839         }
11840     }
11841     if (obj6) {
11842         {
11843             arg7 = wxString_in_helper(obj6);
11844             if (arg7 == NULL) SWIG_fail;
11845             temp7 = true;
11846         }
11847     }
11848     {
11849         PyThreadState* __tstate = wxPyBeginAllowThreads();
11850         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11851
11852         wxPyEndAllowThreads(__tstate);
11853         if (PyErr_Occurred()) SWIG_fail;
11854     }
11855     {
11856         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11857     }
11858     {
11859         if (temp7)
11860         delete arg7;
11861     }
11862     return resultobj;
11863     fail:
11864     {
11865         if (temp7)
11866         delete arg7;
11867     }
11868     return NULL;
11869 }
11870
11871
11872 static PyObject *_wrap_VListBox_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
11873     PyObject *resultobj;
11874     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11875     size_t result;
11876     PyObject * obj0 = 0 ;
11877     char *kwnames[] = {
11878         (char *) "self", NULL
11879     };
11880
11881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetItemCount",kwnames,&obj0)) goto fail;
11882     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11883     if (SWIG_arg_fail(1)) SWIG_fail;
11884     {
11885         PyThreadState* __tstate = wxPyBeginAllowThreads();
11886         result = (size_t)((wxPyVListBox const *)arg1)->GetItemCount();
11887
11888         wxPyEndAllowThreads(__tstate);
11889         if (PyErr_Occurred()) SWIG_fail;
11890     }
11891     {
11892         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11893     }
11894     return resultobj;
11895     fail:
11896     return NULL;
11897 }
11898
11899
11900 static PyObject *_wrap_VListBox_HasMultipleSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11901     PyObject *resultobj;
11902     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11903     bool result;
11904     PyObject * obj0 = 0 ;
11905     char *kwnames[] = {
11906         (char *) "self", NULL
11907     };
11908
11909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_HasMultipleSelection",kwnames,&obj0)) goto fail;
11910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11911     if (SWIG_arg_fail(1)) SWIG_fail;
11912     {
11913         PyThreadState* __tstate = wxPyBeginAllowThreads();
11914         result = (bool)((wxPyVListBox const *)arg1)->HasMultipleSelection();
11915
11916         wxPyEndAllowThreads(__tstate);
11917         if (PyErr_Occurred()) SWIG_fail;
11918     }
11919     {
11920         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11921     }
11922     return resultobj;
11923     fail:
11924     return NULL;
11925 }
11926
11927
11928 static PyObject *_wrap_VListBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11929     PyObject *resultobj;
11930     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11931     int result;
11932     PyObject * obj0 = 0 ;
11933     char *kwnames[] = {
11934         (char *) "self", NULL
11935     };
11936
11937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelection",kwnames,&obj0)) goto fail;
11938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11939     if (SWIG_arg_fail(1)) SWIG_fail;
11940     {
11941         PyThreadState* __tstate = wxPyBeginAllowThreads();
11942         result = (int)((wxPyVListBox const *)arg1)->GetSelection();
11943
11944         wxPyEndAllowThreads(__tstate);
11945         if (PyErr_Occurred()) SWIG_fail;
11946     }
11947     {
11948         resultobj = SWIG_From_int((int)(result));
11949     }
11950     return resultobj;
11951     fail:
11952     return NULL;
11953 }
11954
11955
11956 static PyObject *_wrap_VListBox_IsCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
11957     PyObject *resultobj;
11958     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11959     size_t arg2 ;
11960     bool result;
11961     PyObject * obj0 = 0 ;
11962     PyObject * obj1 = 0 ;
11963     char *kwnames[] = {
11964         (char *) "self",(char *) "item", NULL
11965     };
11966
11967     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsCurrent",kwnames,&obj0,&obj1)) goto fail;
11968     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11969     if (SWIG_arg_fail(1)) SWIG_fail;
11970     {
11971         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11972         if (SWIG_arg_fail(2)) SWIG_fail;
11973     }
11974     {
11975         PyThreadState* __tstate = wxPyBeginAllowThreads();
11976         result = (bool)((wxPyVListBox const *)arg1)->IsCurrent(arg2);
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_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
11991     PyObject *resultobj;
11992     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11993     size_t arg2 ;
11994     bool result;
11995     PyObject * obj0 = 0 ;
11996     PyObject * obj1 = 0 ;
11997     char *kwnames[] = {
11998         (char *) "self",(char *) "item", NULL
11999     };
12000
12001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
12002     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12003     if (SWIG_arg_fail(1)) SWIG_fail;
12004     {
12005         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12006         if (SWIG_arg_fail(2)) SWIG_fail;
12007     }
12008     {
12009         PyThreadState* __tstate = wxPyBeginAllowThreads();
12010         result = (bool)((wxPyVListBox const *)arg1)->IsSelected(arg2);
12011
12012         wxPyEndAllowThreads(__tstate);
12013         if (PyErr_Occurred()) SWIG_fail;
12014     }
12015     {
12016         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017     }
12018     return resultobj;
12019     fail:
12020     return NULL;
12021 }
12022
12023
12024 static PyObject *_wrap_VListBox_GetSelectedCount(PyObject *, PyObject *args, PyObject *kwargs) {
12025     PyObject *resultobj;
12026     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12027     size_t result;
12028     PyObject * obj0 = 0 ;
12029     char *kwnames[] = {
12030         (char *) "self", NULL
12031     };
12032
12033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectedCount",kwnames,&obj0)) goto fail;
12034     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12035     if (SWIG_arg_fail(1)) SWIG_fail;
12036     {
12037         PyThreadState* __tstate = wxPyBeginAllowThreads();
12038         result = (size_t)((wxPyVListBox const *)arg1)->GetSelectedCount();
12039
12040         wxPyEndAllowThreads(__tstate);
12041         if (PyErr_Occurred()) SWIG_fail;
12042     }
12043     {
12044         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
12045     }
12046     return resultobj;
12047     fail:
12048     return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_VListBox_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12053     PyObject *resultobj;
12054     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12055     PyObject *result;
12056     PyObject * obj0 = 0 ;
12057     char *kwnames[] = {
12058         (char *) "self", NULL
12059     };
12060
12061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetFirstSelected",kwnames,&obj0)) goto fail;
12062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12063     if (SWIG_arg_fail(1)) SWIG_fail;
12064     {
12065         PyThreadState* __tstate = wxPyBeginAllowThreads();
12066         result = (PyObject *)wxPyVListBox_GetFirstSelected(arg1);
12067
12068         wxPyEndAllowThreads(__tstate);
12069         if (PyErr_Occurred()) SWIG_fail;
12070     }
12071     resultobj = result;
12072     return resultobj;
12073     fail:
12074     return NULL;
12075 }
12076
12077
12078 static PyObject *_wrap_VListBox_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12079     PyObject *resultobj;
12080     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12081     unsigned long arg2 ;
12082     PyObject *result;
12083     PyObject * obj0 = 0 ;
12084     PyObject * obj1 = 0 ;
12085     char *kwnames[] = {
12086         (char *) "self",(char *) "cookie", NULL
12087     };
12088
12089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
12090     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12091     if (SWIG_arg_fail(1)) SWIG_fail;
12092     {
12093         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
12094         if (SWIG_arg_fail(2)) SWIG_fail;
12095     }
12096     {
12097         PyThreadState* __tstate = wxPyBeginAllowThreads();
12098         result = (PyObject *)wxPyVListBox_GetNextSelected(arg1,arg2);
12099
12100         wxPyEndAllowThreads(__tstate);
12101         if (PyErr_Occurred()) SWIG_fail;
12102     }
12103     resultobj = result;
12104     return resultobj;
12105     fail:
12106     return NULL;
12107 }
12108
12109
12110 static PyObject *_wrap_VListBox_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12111     PyObject *resultobj;
12112     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12113     wxPoint result;
12114     PyObject * obj0 = 0 ;
12115     char *kwnames[] = {
12116         (char *) "self", NULL
12117     };
12118
12119     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetMargins",kwnames,&obj0)) goto fail;
12120     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12121     if (SWIG_arg_fail(1)) SWIG_fail;
12122     {
12123         PyThreadState* __tstate = wxPyBeginAllowThreads();
12124         result = ((wxPyVListBox const *)arg1)->GetMargins();
12125
12126         wxPyEndAllowThreads(__tstate);
12127         if (PyErr_Occurred()) SWIG_fail;
12128     }
12129     {
12130         wxPoint * resultptr;
12131         resultptr = new wxPoint((wxPoint &)(result));
12132         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12133     }
12134     return resultobj;
12135     fail:
12136     return NULL;
12137 }
12138
12139
12140 static PyObject *_wrap_VListBox_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12141     PyObject *resultobj;
12142     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12143     wxColour *result;
12144     PyObject * obj0 = 0 ;
12145     char *kwnames[] = {
12146         (char *) "self", NULL
12147     };
12148
12149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectionBackground",kwnames,&obj0)) goto fail;
12150     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12151     if (SWIG_arg_fail(1)) SWIG_fail;
12152     {
12153         PyThreadState* __tstate = wxPyBeginAllowThreads();
12154         {
12155             wxColour const &_result_ref = ((wxPyVListBox const *)arg1)->GetSelectionBackground();
12156             result = (wxColour *) &_result_ref;
12157         }
12158
12159         wxPyEndAllowThreads(__tstate);
12160         if (PyErr_Occurred()) SWIG_fail;
12161     }
12162     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
12163     return resultobj;
12164     fail:
12165     return NULL;
12166 }
12167
12168
12169 static PyObject *_wrap_VListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12170     PyObject *resultobj;
12171     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12172     size_t arg2 ;
12173     PyObject * obj0 = 0 ;
12174     PyObject * obj1 = 0 ;
12175     char *kwnames[] = {
12176         (char *) "self",(char *) "count", NULL
12177     };
12178
12179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12181     if (SWIG_arg_fail(1)) SWIG_fail;
12182     {
12183         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12184         if (SWIG_arg_fail(2)) SWIG_fail;
12185     }
12186     {
12187         PyThreadState* __tstate = wxPyBeginAllowThreads();
12188         (arg1)->SetItemCount(arg2);
12189
12190         wxPyEndAllowThreads(__tstate);
12191         if (PyErr_Occurred()) SWIG_fail;
12192     }
12193     Py_INCREF(Py_None); resultobj = Py_None;
12194     return resultobj;
12195     fail:
12196     return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_VListBox_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
12201     PyObject *resultobj;
12202     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12203     PyObject * obj0 = 0 ;
12204     char *kwnames[] = {
12205         (char *) "self", NULL
12206     };
12207
12208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_Clear",kwnames,&obj0)) goto fail;
12209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12210     if (SWIG_arg_fail(1)) SWIG_fail;
12211     {
12212         PyThreadState* __tstate = wxPyBeginAllowThreads();
12213         (arg1)->Clear();
12214
12215         wxPyEndAllowThreads(__tstate);
12216         if (PyErr_Occurred()) SWIG_fail;
12217     }
12218     Py_INCREF(Py_None); resultobj = Py_None;
12219     return resultobj;
12220     fail:
12221     return NULL;
12222 }
12223
12224
12225 static PyObject *_wrap_VListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
12226     PyObject *resultobj;
12227     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12228     int arg2 ;
12229     PyObject * obj0 = 0 ;
12230     PyObject * obj1 = 0 ;
12231     char *kwnames[] = {
12232         (char *) "self",(char *) "selection", NULL
12233     };
12234
12235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
12236     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12237     if (SWIG_arg_fail(1)) SWIG_fail;
12238     {
12239         arg2 = (int)(SWIG_As_int(obj1));
12240         if (SWIG_arg_fail(2)) SWIG_fail;
12241     }
12242     {
12243         PyThreadState* __tstate = wxPyBeginAllowThreads();
12244         (arg1)->SetSelection(arg2);
12245
12246         wxPyEndAllowThreads(__tstate);
12247         if (PyErr_Occurred()) SWIG_fail;
12248     }
12249     Py_INCREF(Py_None); resultobj = Py_None;
12250     return resultobj;
12251     fail:
12252     return NULL;
12253 }
12254
12255
12256 static PyObject *_wrap_VListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
12257     PyObject *resultobj;
12258     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12259     size_t arg2 ;
12260     bool arg3 = (bool) true ;
12261     bool result;
12262     PyObject * obj0 = 0 ;
12263     PyObject * obj1 = 0 ;
12264     PyObject * obj2 = 0 ;
12265     char *kwnames[] = {
12266         (char *) "self",(char *) "item",(char *) "select", NULL
12267     };
12268
12269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:VListBox_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
12270     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12271     if (SWIG_arg_fail(1)) SWIG_fail;
12272     {
12273         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12274         if (SWIG_arg_fail(2)) SWIG_fail;
12275     }
12276     if (obj2) {
12277         {
12278             arg3 = (bool)(SWIG_As_bool(obj2));
12279             if (SWIG_arg_fail(3)) SWIG_fail;
12280         }
12281     }
12282     {
12283         PyThreadState* __tstate = wxPyBeginAllowThreads();
12284         result = (bool)(arg1)->Select(arg2,arg3);
12285
12286         wxPyEndAllowThreads(__tstate);
12287         if (PyErr_Occurred()) SWIG_fail;
12288     }
12289     {
12290         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12291     }
12292     return resultobj;
12293     fail:
12294     return NULL;
12295 }
12296
12297
12298 static PyObject *_wrap_VListBox_SelectRange(PyObject *, PyObject *args, PyObject *kwargs) {
12299     PyObject *resultobj;
12300     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12301     size_t arg2 ;
12302     size_t arg3 ;
12303     bool result;
12304     PyObject * obj0 = 0 ;
12305     PyObject * obj1 = 0 ;
12306     PyObject * obj2 = 0 ;
12307     char *kwnames[] = {
12308         (char *) "self",(char *) "from",(char *) "to", NULL
12309     };
12310
12311     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SelectRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12312     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12313     if (SWIG_arg_fail(1)) SWIG_fail;
12314     {
12315         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12316         if (SWIG_arg_fail(2)) SWIG_fail;
12317     }
12318     {
12319         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12320         if (SWIG_arg_fail(3)) SWIG_fail;
12321     }
12322     {
12323         PyThreadState* __tstate = wxPyBeginAllowThreads();
12324         result = (bool)(arg1)->SelectRange(arg2,arg3);
12325
12326         wxPyEndAllowThreads(__tstate);
12327         if (PyErr_Occurred()) SWIG_fail;
12328     }
12329     {
12330         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12331     }
12332     return resultobj;
12333     fail:
12334     return NULL;
12335 }
12336
12337
12338 static PyObject *_wrap_VListBox_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
12339     PyObject *resultobj;
12340     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12341     size_t arg2 ;
12342     PyObject * obj0 = 0 ;
12343     PyObject * obj1 = 0 ;
12344     char *kwnames[] = {
12345         (char *) "self",(char *) "item", NULL
12346     };
12347
12348     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_Toggle",kwnames,&obj0,&obj1)) goto fail;
12349     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12350     if (SWIG_arg_fail(1)) SWIG_fail;
12351     {
12352         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12353         if (SWIG_arg_fail(2)) SWIG_fail;
12354     }
12355     {
12356         PyThreadState* __tstate = wxPyBeginAllowThreads();
12357         (arg1)->Toggle(arg2);
12358
12359         wxPyEndAllowThreads(__tstate);
12360         if (PyErr_Occurred()) SWIG_fail;
12361     }
12362     Py_INCREF(Py_None); resultobj = Py_None;
12363     return resultobj;
12364     fail:
12365     return NULL;
12366 }
12367
12368
12369 static PyObject *_wrap_VListBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12370     PyObject *resultobj;
12371     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12372     bool result;
12373     PyObject * obj0 = 0 ;
12374     char *kwnames[] = {
12375         (char *) "self", NULL
12376     };
12377
12378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_SelectAll",kwnames,&obj0)) goto fail;
12379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12380     if (SWIG_arg_fail(1)) SWIG_fail;
12381     {
12382         PyThreadState* __tstate = wxPyBeginAllowThreads();
12383         result = (bool)(arg1)->SelectAll();
12384
12385         wxPyEndAllowThreads(__tstate);
12386         if (PyErr_Occurred()) SWIG_fail;
12387     }
12388     {
12389         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12390     }
12391     return resultobj;
12392     fail:
12393     return NULL;
12394 }
12395
12396
12397 static PyObject *_wrap_VListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12398     PyObject *resultobj;
12399     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12400     bool result;
12401     PyObject * obj0 = 0 ;
12402     char *kwnames[] = {
12403         (char *) "self", NULL
12404     };
12405
12406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_DeselectAll",kwnames,&obj0)) goto fail;
12407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12408     if (SWIG_arg_fail(1)) SWIG_fail;
12409     {
12410         PyThreadState* __tstate = wxPyBeginAllowThreads();
12411         result = (bool)(arg1)->DeselectAll();
12412
12413         wxPyEndAllowThreads(__tstate);
12414         if (PyErr_Occurred()) SWIG_fail;
12415     }
12416     {
12417         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12418     }
12419     return resultobj;
12420     fail:
12421     return NULL;
12422 }
12423
12424
12425 static PyObject *_wrap_VListBox_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12426     PyObject *resultobj;
12427     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12428     wxPoint *arg2 = 0 ;
12429     wxPoint temp2 ;
12430     PyObject * obj0 = 0 ;
12431     PyObject * obj1 = 0 ;
12432     char *kwnames[] = {
12433         (char *) "self",(char *) "pt", NULL
12434     };
12435
12436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetMargins",kwnames,&obj0,&obj1)) goto fail;
12437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12438     if (SWIG_arg_fail(1)) SWIG_fail;
12439     {
12440         arg2 = &temp2;
12441         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12442     }
12443     {
12444         PyThreadState* __tstate = wxPyBeginAllowThreads();
12445         (arg1)->SetMargins((wxPoint const &)*arg2);
12446
12447         wxPyEndAllowThreads(__tstate);
12448         if (PyErr_Occurred()) SWIG_fail;
12449     }
12450     Py_INCREF(Py_None); resultobj = Py_None;
12451     return resultobj;
12452     fail:
12453     return NULL;
12454 }
12455
12456
12457 static PyObject *_wrap_VListBox_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
12458     PyObject *resultobj;
12459     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12460     int arg2 ;
12461     int arg3 ;
12462     PyObject * obj0 = 0 ;
12463     PyObject * obj1 = 0 ;
12464     PyObject * obj2 = 0 ;
12465     char *kwnames[] = {
12466         (char *) "self",(char *) "x",(char *) "y", NULL
12467     };
12468
12469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
12470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12471     if (SWIG_arg_fail(1)) SWIG_fail;
12472     {
12473         arg2 = (int)(SWIG_As_int(obj1));
12474         if (SWIG_arg_fail(2)) SWIG_fail;
12475     }
12476     {
12477         arg3 = (int)(SWIG_As_int(obj2));
12478         if (SWIG_arg_fail(3)) SWIG_fail;
12479     }
12480     {
12481         PyThreadState* __tstate = wxPyBeginAllowThreads();
12482         (arg1)->SetMargins(arg2,arg3);
12483
12484         wxPyEndAllowThreads(__tstate);
12485         if (PyErr_Occurred()) SWIG_fail;
12486     }
12487     Py_INCREF(Py_None); resultobj = Py_None;
12488     return resultobj;
12489     fail:
12490     return NULL;
12491 }
12492
12493
12494 static PyObject *_wrap_VListBox_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12495     PyObject *resultobj;
12496     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12497     wxColour *arg2 = 0 ;
12498     wxColour temp2 ;
12499     PyObject * obj0 = 0 ;
12500     PyObject * obj1 = 0 ;
12501     char *kwnames[] = {
12502         (char *) "self",(char *) "col", NULL
12503     };
12504
12505     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
12506     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12507     if (SWIG_arg_fail(1)) SWIG_fail;
12508     {
12509         arg2 = &temp2;
12510         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12511     }
12512     {
12513         PyThreadState* __tstate = wxPyBeginAllowThreads();
12514         (arg1)->SetSelectionBackground((wxColour const &)*arg2);
12515
12516         wxPyEndAllowThreads(__tstate);
12517         if (PyErr_Occurred()) SWIG_fail;
12518     }
12519     Py_INCREF(Py_None); resultobj = Py_None;
12520     return resultobj;
12521     fail:
12522     return NULL;
12523 }
12524
12525
12526 static PyObject * VListBox_swigregister(PyObject *, PyObject *args) {
12527     PyObject *obj;
12528     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12529     SWIG_TypeClientData(SWIGTYPE_p_wxPyVListBox, obj);
12530     Py_INCREF(obj);
12531     return Py_BuildValue((char *)"");
12532 }
12533 static PyObject *_wrap_new_HtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12534     PyObject *resultobj;
12535     wxWindow *arg1 = (wxWindow *) 0 ;
12536     int arg2 = (int) wxID_ANY ;
12537     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12538     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12539     wxSize const &arg4_defvalue = wxDefaultSize ;
12540     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12541     long arg5 = (long) 0 ;
12542     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
12543     wxString *arg6 = (wxString *) &arg6_defvalue ;
12544     wxPyHtmlListBox *result;
12545     wxPoint temp3 ;
12546     wxSize temp4 ;
12547     bool temp6 = false ;
12548     PyObject * obj0 = 0 ;
12549     PyObject * obj1 = 0 ;
12550     PyObject * obj2 = 0 ;
12551     PyObject * obj3 = 0 ;
12552     PyObject * obj4 = 0 ;
12553     PyObject * obj5 = 0 ;
12554     char *kwnames[] = {
12555         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12556     };
12557
12558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_HtmlListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12559     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12560     if (SWIG_arg_fail(1)) SWIG_fail;
12561     if (obj1) {
12562         {
12563             arg2 = (int)(SWIG_As_int(obj1));
12564             if (SWIG_arg_fail(2)) SWIG_fail;
12565         }
12566     }
12567     if (obj2) {
12568         {
12569             arg3 = &temp3;
12570             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12571         }
12572     }
12573     if (obj3) {
12574         {
12575             arg4 = &temp4;
12576             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12577         }
12578     }
12579     if (obj4) {
12580         {
12581             arg5 = (long)(SWIG_As_long(obj4));
12582             if (SWIG_arg_fail(5)) SWIG_fail;
12583         }
12584     }
12585     if (obj5) {
12586         {
12587             arg6 = wxString_in_helper(obj5);
12588             if (arg6 == NULL) SWIG_fail;
12589             temp6 = true;
12590         }
12591     }
12592     {
12593         if (!wxPyCheckForApp()) SWIG_fail;
12594         PyThreadState* __tstate = wxPyBeginAllowThreads();
12595         result = (wxPyHtmlListBox *)new wxPyHtmlListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12596
12597         wxPyEndAllowThreads(__tstate);
12598         if (PyErr_Occurred()) SWIG_fail;
12599     }
12600     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12601     {
12602         if (temp6)
12603         delete arg6;
12604     }
12605     return resultobj;
12606     fail:
12607     {
12608         if (temp6)
12609         delete arg6;
12610     }
12611     return NULL;
12612 }
12613
12614
12615 static PyObject *_wrap_new_PreHtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12616     PyObject *resultobj;
12617     wxPyHtmlListBox *result;
12618     char *kwnames[] = {
12619         NULL
12620     };
12621
12622     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreHtmlListBox",kwnames)) goto fail;
12623     {
12624         if (!wxPyCheckForApp()) SWIG_fail;
12625         PyThreadState* __tstate = wxPyBeginAllowThreads();
12626         result = (wxPyHtmlListBox *)new wxPyHtmlListBox();
12627
12628         wxPyEndAllowThreads(__tstate);
12629         if (PyErr_Occurred()) SWIG_fail;
12630     }
12631     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12632     return resultobj;
12633     fail:
12634     return NULL;
12635 }
12636
12637
12638 static PyObject *_wrap_HtmlListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12639     PyObject *resultobj;
12640     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12641     PyObject *arg2 = (PyObject *) 0 ;
12642     PyObject *arg3 = (PyObject *) 0 ;
12643     PyObject * obj0 = 0 ;
12644     PyObject * obj1 = 0 ;
12645     PyObject * obj2 = 0 ;
12646     char *kwnames[] = {
12647         (char *) "self",(char *) "self",(char *) "_class", NULL
12648     };
12649
12650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HtmlListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
12651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12652     if (SWIG_arg_fail(1)) SWIG_fail;
12653     arg2 = obj1;
12654     arg3 = obj2;
12655     {
12656         PyThreadState* __tstate = wxPyBeginAllowThreads();
12657         (arg1)->_setCallbackInfo(arg2,arg3);
12658
12659         wxPyEndAllowThreads(__tstate);
12660         if (PyErr_Occurred()) SWIG_fail;
12661     }
12662     Py_INCREF(Py_None); resultobj = Py_None;
12663     return resultobj;
12664     fail:
12665     return NULL;
12666 }
12667
12668
12669 static PyObject *_wrap_HtmlListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12670     PyObject *resultobj;
12671     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12672     wxWindow *arg2 = (wxWindow *) 0 ;
12673     int arg3 = (int) wxID_ANY ;
12674     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12675     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12676     wxSize const &arg5_defvalue = wxDefaultSize ;
12677     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12678     long arg6 = (long) 0 ;
12679     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
12680     wxString *arg7 = (wxString *) &arg7_defvalue ;
12681     bool result;
12682     wxPoint temp4 ;
12683     wxSize temp5 ;
12684     bool temp7 = false ;
12685     PyObject * obj0 = 0 ;
12686     PyObject * obj1 = 0 ;
12687     PyObject * obj2 = 0 ;
12688     PyObject * obj3 = 0 ;
12689     PyObject * obj4 = 0 ;
12690     PyObject * obj5 = 0 ;
12691     PyObject * obj6 = 0 ;
12692     char *kwnames[] = {
12693         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12694     };
12695
12696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:HtmlListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12698     if (SWIG_arg_fail(1)) SWIG_fail;
12699     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12700     if (SWIG_arg_fail(2)) SWIG_fail;
12701     if (obj2) {
12702         {
12703             arg3 = (int)(SWIG_As_int(obj2));
12704             if (SWIG_arg_fail(3)) SWIG_fail;
12705         }
12706     }
12707     if (obj3) {
12708         {
12709             arg4 = &temp4;
12710             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12711         }
12712     }
12713     if (obj4) {
12714         {
12715             arg5 = &temp5;
12716             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12717         }
12718     }
12719     if (obj5) {
12720         {
12721             arg6 = (long)(SWIG_As_long(obj5));
12722             if (SWIG_arg_fail(6)) SWIG_fail;
12723         }
12724     }
12725     if (obj6) {
12726         {
12727             arg7 = wxString_in_helper(obj6);
12728             if (arg7 == NULL) SWIG_fail;
12729             temp7 = true;
12730         }
12731     }
12732     {
12733         PyThreadState* __tstate = wxPyBeginAllowThreads();
12734         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12735
12736         wxPyEndAllowThreads(__tstate);
12737         if (PyErr_Occurred()) SWIG_fail;
12738     }
12739     {
12740         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12741     }
12742     {
12743         if (temp7)
12744         delete arg7;
12745     }
12746     return resultobj;
12747     fail:
12748     {
12749         if (temp7)
12750         delete arg7;
12751     }
12752     return NULL;
12753 }
12754
12755
12756 static PyObject *_wrap_HtmlListBox_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
12757     PyObject *resultobj;
12758     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12759     PyObject * obj0 = 0 ;
12760     char *kwnames[] = {
12761         (char *) "self", NULL
12762     };
12763
12764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_RefreshAll",kwnames,&obj0)) goto fail;
12765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12766     if (SWIG_arg_fail(1)) SWIG_fail;
12767     {
12768         PyThreadState* __tstate = wxPyBeginAllowThreads();
12769         (arg1)->RefreshAll();
12770
12771         wxPyEndAllowThreads(__tstate);
12772         if (PyErr_Occurred()) SWIG_fail;
12773     }
12774     Py_INCREF(Py_None); resultobj = Py_None;
12775     return resultobj;
12776     fail:
12777     return NULL;
12778 }
12779
12780
12781 static PyObject *_wrap_HtmlListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12782     PyObject *resultobj;
12783     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12784     size_t arg2 ;
12785     PyObject * obj0 = 0 ;
12786     PyObject * obj1 = 0 ;
12787     char *kwnames[] = {
12788         (char *) "self",(char *) "count", NULL
12789     };
12790
12791     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HtmlListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12792     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12793     if (SWIG_arg_fail(1)) SWIG_fail;
12794     {
12795         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12796         if (SWIG_arg_fail(2)) SWIG_fail;
12797     }
12798     {
12799         PyThreadState* __tstate = wxPyBeginAllowThreads();
12800         (arg1)->SetItemCount(arg2);
12801
12802         wxPyEndAllowThreads(__tstate);
12803         if (PyErr_Occurred()) SWIG_fail;
12804     }
12805     Py_INCREF(Py_None); resultobj = Py_None;
12806     return resultobj;
12807     fail:
12808     return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_HtmlListBox_GetFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
12813     PyObject *resultobj;
12814     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12815     wxFileSystem *result;
12816     PyObject * obj0 = 0 ;
12817     char *kwnames[] = {
12818         (char *) "self", NULL
12819     };
12820
12821     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_GetFileSystem",kwnames,&obj0)) goto fail;
12822     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12823     if (SWIG_arg_fail(1)) SWIG_fail;
12824     {
12825         PyThreadState* __tstate = wxPyBeginAllowThreads();
12826         {
12827             wxFileSystem &_result_ref = (arg1)->GetFileSystem();
12828             result = (wxFileSystem *) &_result_ref;
12829         }
12830
12831         wxPyEndAllowThreads(__tstate);
12832         if (PyErr_Occurred()) SWIG_fail;
12833     }
12834     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileSystem, 0);
12835     return resultobj;
12836     fail:
12837     return NULL;
12838 }
12839
12840
12841 static PyObject * HtmlListBox_swigregister(PyObject *, PyObject *args) {
12842     PyObject *obj;
12843     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12844     SWIG_TypeClientData(SWIGTYPE_p_wxPyHtmlListBox, obj);
12845     Py_INCREF(obj);
12846     return Py_BuildValue((char *)"");
12847 }
12848 static PyObject *_wrap_new_TaskBarIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12849     PyObject *resultobj;
12850     wxPyTaskBarIcon *result;
12851     char *kwnames[] = {
12852         NULL
12853     };
12854
12855     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TaskBarIcon",kwnames)) goto fail;
12856     {
12857         if (!wxPyCheckForApp()) SWIG_fail;
12858         PyThreadState* __tstate = wxPyBeginAllowThreads();
12859         result = (wxPyTaskBarIcon *)new wxPyTaskBarIcon();
12860
12861         wxPyEndAllowThreads(__tstate);
12862         if (PyErr_Occurred()) SWIG_fail;
12863     }
12864     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTaskBarIcon, 1);
12865     return resultobj;
12866     fail:
12867     return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_TaskBarIcon__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12872     PyObject *resultobj;
12873     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12874     PyObject *arg2 = (PyObject *) 0 ;
12875     PyObject *arg3 = (PyObject *) 0 ;
12876     int arg4 ;
12877     PyObject * obj0 = 0 ;
12878     PyObject * obj1 = 0 ;
12879     PyObject * obj2 = 0 ;
12880     PyObject * obj3 = 0 ;
12881     char *kwnames[] = {
12882         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12883     };
12884
12885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TaskBarIcon__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12887     if (SWIG_arg_fail(1)) SWIG_fail;
12888     arg2 = obj1;
12889     arg3 = obj2;
12890     {
12891         arg4 = (int)(SWIG_As_int(obj3));
12892         if (SWIG_arg_fail(4)) SWIG_fail;
12893     }
12894     {
12895         PyThreadState* __tstate = wxPyBeginAllowThreads();
12896         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12897
12898         wxPyEndAllowThreads(__tstate);
12899         if (PyErr_Occurred()) SWIG_fail;
12900     }
12901     Py_INCREF(Py_None); resultobj = Py_None;
12902     return resultobj;
12903     fail:
12904     return NULL;
12905 }
12906
12907
12908 static PyObject *_wrap_TaskBarIcon_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
12909     PyObject *resultobj;
12910     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12911     PyObject * obj0 = 0 ;
12912     char *kwnames[] = {
12913         (char *) "self", NULL
12914     };
12915
12916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_Destroy",kwnames,&obj0)) goto fail;
12917     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12918     if (SWIG_arg_fail(1)) SWIG_fail;
12919     {
12920         PyThreadState* __tstate = wxPyBeginAllowThreads();
12921         wxPyTaskBarIcon_Destroy(arg1);
12922
12923         wxPyEndAllowThreads(__tstate);
12924         if (PyErr_Occurred()) SWIG_fail;
12925     }
12926     Py_INCREF(Py_None); resultobj = Py_None;
12927     return resultobj;
12928     fail:
12929     return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_TaskBarIcon_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12934     PyObject *resultobj;
12935     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12936     bool result;
12937     PyObject * obj0 = 0 ;
12938     char *kwnames[] = {
12939         (char *) "self", NULL
12940     };
12941
12942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsOk",kwnames,&obj0)) goto fail;
12943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12944     if (SWIG_arg_fail(1)) SWIG_fail;
12945     {
12946         PyThreadState* __tstate = wxPyBeginAllowThreads();
12947         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsOk();
12948
12949         wxPyEndAllowThreads(__tstate);
12950         if (PyErr_Occurred()) SWIG_fail;
12951     }
12952     {
12953         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12954     }
12955     return resultobj;
12956     fail:
12957     return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_TaskBarIcon_IsIconInstalled(PyObject *, PyObject *args, PyObject *kwargs) {
12962     PyObject *resultobj;
12963     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12964     bool result;
12965     PyObject * obj0 = 0 ;
12966     char *kwnames[] = {
12967         (char *) "self", NULL
12968     };
12969
12970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsIconInstalled",kwnames,&obj0)) goto fail;
12971     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12972     if (SWIG_arg_fail(1)) SWIG_fail;
12973     {
12974         PyThreadState* __tstate = wxPyBeginAllowThreads();
12975         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsIconInstalled();
12976
12977         wxPyEndAllowThreads(__tstate);
12978         if (PyErr_Occurred()) SWIG_fail;
12979     }
12980     {
12981         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12982     }
12983     return resultobj;
12984     fail:
12985     return NULL;
12986 }
12987
12988
12989 static PyObject *_wrap_TaskBarIcon_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12990     PyObject *resultobj;
12991     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12992     wxIcon *arg2 = 0 ;
12993     wxString const &arg3_defvalue = wxPyEmptyString ;
12994     wxString *arg3 = (wxString *) &arg3_defvalue ;
12995     bool result;
12996     bool temp3 = false ;
12997     PyObject * obj0 = 0 ;
12998     PyObject * obj1 = 0 ;
12999     PyObject * obj2 = 0 ;
13000     char *kwnames[] = {
13001         (char *) "self",(char *) "icon",(char *) "tooltip", NULL
13002     };
13003
13004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TaskBarIcon_SetIcon",kwnames,&obj0,&obj1,&obj2)) 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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13009         if (SWIG_arg_fail(2)) SWIG_fail;
13010         if (arg2 == NULL) {
13011             SWIG_null_ref("wxIcon");
13012         }
13013         if (SWIG_arg_fail(2)) SWIG_fail;
13014     }
13015     if (obj2) {
13016         {
13017             arg3 = wxString_in_helper(obj2);
13018             if (arg3 == NULL) SWIG_fail;
13019             temp3 = true;
13020         }
13021     }
13022     {
13023         PyThreadState* __tstate = wxPyBeginAllowThreads();
13024         result = (bool)(arg1)->SetIcon((wxIcon const &)*arg2,(wxString const &)*arg3);
13025
13026         wxPyEndAllowThreads(__tstate);
13027         if (PyErr_Occurred()) SWIG_fail;
13028     }
13029     {
13030         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13031     }
13032     {
13033         if (temp3)
13034         delete arg3;
13035     }
13036     return resultobj;
13037     fail:
13038     {
13039         if (temp3)
13040         delete arg3;
13041     }
13042     return NULL;
13043 }
13044
13045
13046 static PyObject *_wrap_TaskBarIcon_RemoveIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13047     PyObject *resultobj;
13048     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13049     bool result;
13050     PyObject * obj0 = 0 ;
13051     char *kwnames[] = {
13052         (char *) "self", NULL
13053     };
13054
13055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_RemoveIcon",kwnames,&obj0)) goto fail;
13056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13057     if (SWIG_arg_fail(1)) SWIG_fail;
13058     {
13059         PyThreadState* __tstate = wxPyBeginAllowThreads();
13060         result = (bool)(arg1)->RemoveIcon();
13061
13062         wxPyEndAllowThreads(__tstate);
13063         if (PyErr_Occurred()) SWIG_fail;
13064     }
13065     {
13066         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13067     }
13068     return resultobj;
13069     fail:
13070     return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_TaskBarIcon_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
13075     PyObject *resultobj;
13076     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13077     wxMenu *arg2 = (wxMenu *) 0 ;
13078     bool result;
13079     PyObject * obj0 = 0 ;
13080     PyObject * obj1 = 0 ;
13081     char *kwnames[] = {
13082         (char *) "self",(char *) "menu", NULL
13083     };
13084
13085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TaskBarIcon_PopupMenu",kwnames,&obj0,&obj1)) goto fail;
13086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13087     if (SWIG_arg_fail(1)) SWIG_fail;
13088     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
13089     if (SWIG_arg_fail(2)) SWIG_fail;
13090     {
13091         PyThreadState* __tstate = wxPyBeginAllowThreads();
13092         result = (bool)(arg1)->PopupMenu(arg2);
13093
13094         wxPyEndAllowThreads(__tstate);
13095         if (PyErr_Occurred()) SWIG_fail;
13096     }
13097     {
13098         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13099     }
13100     return resultobj;
13101     fail:
13102     return NULL;
13103 }
13104
13105
13106 static PyObject * TaskBarIcon_swigregister(PyObject *, PyObject *args) {
13107     PyObject *obj;
13108     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13109     SWIG_TypeClientData(SWIGTYPE_p_wxPyTaskBarIcon, obj);
13110     Py_INCREF(obj);
13111     return Py_BuildValue((char *)"");
13112 }
13113 static PyObject *_wrap_new_TaskBarIconEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13114     PyObject *resultobj;
13115     wxEventType arg1 ;
13116     wxTaskBarIcon *arg2 = (wxTaskBarIcon *) 0 ;
13117     wxTaskBarIconEvent *result;
13118     PyObject * obj0 = 0 ;
13119     PyObject * obj1 = 0 ;
13120     char *kwnames[] = {
13121         (char *) "evtType",(char *) "tbIcon", NULL
13122     };
13123
13124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_TaskBarIconEvent",kwnames,&obj0,&obj1)) goto fail;
13125     {
13126         arg1 = (wxEventType)(SWIG_As_int(obj0));
13127         if (SWIG_arg_fail(1)) SWIG_fail;
13128     }
13129     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13130     if (SWIG_arg_fail(2)) SWIG_fail;
13131     {
13132         PyThreadState* __tstate = wxPyBeginAllowThreads();
13133         result = (wxTaskBarIconEvent *)new wxTaskBarIconEvent(arg1,arg2);
13134
13135         wxPyEndAllowThreads(__tstate);
13136         if (PyErr_Occurred()) SWIG_fail;
13137     }
13138     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTaskBarIconEvent, 1);
13139     return resultobj;
13140     fail:
13141     return NULL;
13142 }
13143
13144
13145 static PyObject * TaskBarIconEvent_swigregister(PyObject *, PyObject *args) {
13146     PyObject *obj;
13147     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13148     SWIG_TypeClientData(SWIGTYPE_p_wxTaskBarIconEvent, obj);
13149     Py_INCREF(obj);
13150     return Py_BuildValue((char *)"");
13151 }
13152 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
13153     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
13154     return 1;
13155 }
13156
13157
13158 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
13159     PyObject *pyobj;
13160
13161     {
13162 #if wxUSE_UNICODE
13163         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13164 #else
13165         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13166 #endif
13167     }
13168     return pyobj;
13169 }
13170
13171
13172 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
13173     PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
13174     return 1;
13175 }
13176
13177
13178 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
13179     PyObject *pyobj;
13180
13181     {
13182 #if wxUSE_UNICODE
13183         pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13184 #else
13185         pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13186 #endif
13187     }
13188     return pyobj;
13189 }
13190
13191
13192 static int _wrap_DirDialogNameStr_set(PyObject *) {
13193     PyErr_SetString(PyExc_TypeError,"Variable DirDialogNameStr is read-only.");
13194     return 1;
13195 }
13196
13197
13198 static PyObject *_wrap_DirDialogNameStr_get(void) {
13199     PyObject *pyobj;
13200
13201     {
13202 #if wxUSE_UNICODE
13203         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13204 #else
13205         pyobj = PyString_FromStringAndSize((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13206 #endif
13207     }
13208     return pyobj;
13209 }
13210
13211
13212 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
13213     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
13214     return 1;
13215 }
13216
13217
13218 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
13219     PyObject *pyobj;
13220
13221     {
13222 #if wxUSE_UNICODE
13223         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13224 #else
13225         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13226 #endif
13227     }
13228     return pyobj;
13229 }
13230
13231
13232 static int _wrap_GetTextFromUserPromptStr_set(PyObject *) {
13233     PyErr_SetString(PyExc_TypeError,"Variable GetTextFromUserPromptStr is read-only.");
13234     return 1;
13235 }
13236
13237
13238 static PyObject *_wrap_GetTextFromUserPromptStr_get(void) {
13239     PyObject *pyobj;
13240
13241     {
13242 #if wxUSE_UNICODE
13243         pyobj = PyUnicode_FromWideChar((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13244 #else
13245         pyobj = PyString_FromStringAndSize((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13246 #endif
13247     }
13248     return pyobj;
13249 }
13250
13251
13252 static int _wrap_MessageBoxCaptionStr_set(PyObject *) {
13253     PyErr_SetString(PyExc_TypeError,"Variable MessageBoxCaptionStr is read-only.");
13254     return 1;
13255 }
13256
13257
13258 static PyObject *_wrap_MessageBoxCaptionStr_get(void) {
13259     PyObject *pyobj;
13260
13261     {
13262 #if wxUSE_UNICODE
13263         pyobj = PyUnicode_FromWideChar((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13264 #else
13265         pyobj = PyString_FromStringAndSize((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13266 #endif
13267     }
13268     return pyobj;
13269 }
13270
13271
13272 static PyObject *_wrap_new_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13273     PyObject *resultobj;
13274     wxColourData *result;
13275     char *kwnames[] = {
13276         NULL
13277     };
13278
13279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourData",kwnames)) goto fail;
13280     {
13281         PyThreadState* __tstate = wxPyBeginAllowThreads();
13282         result = (wxColourData *)new wxColourData();
13283
13284         wxPyEndAllowThreads(__tstate);
13285         if (PyErr_Occurred()) SWIG_fail;
13286     }
13287     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 1);
13288     return resultobj;
13289     fail:
13290     return NULL;
13291 }
13292
13293
13294 static PyObject *_wrap_delete_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13295     PyObject *resultobj;
13296     wxColourData *arg1 = (wxColourData *) 0 ;
13297     PyObject * obj0 = 0 ;
13298     char *kwnames[] = {
13299         (char *) "self", NULL
13300     };
13301
13302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourData",kwnames,&obj0)) goto fail;
13303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13304     if (SWIG_arg_fail(1)) SWIG_fail;
13305     {
13306         PyThreadState* __tstate = wxPyBeginAllowThreads();
13307         delete arg1;
13308
13309         wxPyEndAllowThreads(__tstate);
13310         if (PyErr_Occurred()) SWIG_fail;
13311     }
13312     Py_INCREF(Py_None); resultobj = Py_None;
13313     return resultobj;
13314     fail:
13315     return NULL;
13316 }
13317
13318
13319 static PyObject *_wrap_ColourData_GetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13320     PyObject *resultobj;
13321     wxColourData *arg1 = (wxColourData *) 0 ;
13322     bool result;
13323     PyObject * obj0 = 0 ;
13324     char *kwnames[] = {
13325         (char *) "self", NULL
13326     };
13327
13328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetChooseFull",kwnames,&obj0)) goto fail;
13329     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13330     if (SWIG_arg_fail(1)) SWIG_fail;
13331     {
13332         PyThreadState* __tstate = wxPyBeginAllowThreads();
13333         result = (bool)(arg1)->GetChooseFull();
13334
13335         wxPyEndAllowThreads(__tstate);
13336         if (PyErr_Occurred()) SWIG_fail;
13337     }
13338     {
13339         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13340     }
13341     return resultobj;
13342     fail:
13343     return NULL;
13344 }
13345
13346
13347 static PyObject *_wrap_ColourData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13348     PyObject *resultobj;
13349     wxColourData *arg1 = (wxColourData *) 0 ;
13350     wxColour result;
13351     PyObject * obj0 = 0 ;
13352     char *kwnames[] = {
13353         (char *) "self", NULL
13354     };
13355
13356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetColour",kwnames,&obj0)) goto fail;
13357     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13358     if (SWIG_arg_fail(1)) SWIG_fail;
13359     {
13360         PyThreadState* __tstate = wxPyBeginAllowThreads();
13361         result = (arg1)->GetColour();
13362
13363         wxPyEndAllowThreads(__tstate);
13364         if (PyErr_Occurred()) SWIG_fail;
13365     }
13366     {
13367         wxColour * resultptr;
13368         resultptr = new wxColour((wxColour &)(result));
13369         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13370     }
13371     return resultobj;
13372     fail:
13373     return NULL;
13374 }
13375
13376
13377 static PyObject *_wrap_ColourData_GetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13378     PyObject *resultobj;
13379     wxColourData *arg1 = (wxColourData *) 0 ;
13380     int arg2 ;
13381     wxColour result;
13382     PyObject * obj0 = 0 ;
13383     PyObject * obj1 = 0 ;
13384     char *kwnames[] = {
13385         (char *) "self",(char *) "i", NULL
13386     };
13387
13388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_GetCustomColour",kwnames,&obj0,&obj1)) goto fail;
13389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13390     if (SWIG_arg_fail(1)) SWIG_fail;
13391     {
13392         arg2 = (int)(SWIG_As_int(obj1));
13393         if (SWIG_arg_fail(2)) SWIG_fail;
13394     }
13395     {
13396         PyThreadState* __tstate = wxPyBeginAllowThreads();
13397         result = (arg1)->GetCustomColour(arg2);
13398
13399         wxPyEndAllowThreads(__tstate);
13400         if (PyErr_Occurred()) SWIG_fail;
13401     }
13402     {
13403         wxColour * resultptr;
13404         resultptr = new wxColour((wxColour &)(result));
13405         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13406     }
13407     return resultobj;
13408     fail:
13409     return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_ColourData_SetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13414     PyObject *resultobj;
13415     wxColourData *arg1 = (wxColourData *) 0 ;
13416     int arg2 ;
13417     PyObject * obj0 = 0 ;
13418     PyObject * obj1 = 0 ;
13419     char *kwnames[] = {
13420         (char *) "self",(char *) "flag", NULL
13421     };
13422
13423     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetChooseFull",kwnames,&obj0,&obj1)) goto fail;
13424     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13425     if (SWIG_arg_fail(1)) SWIG_fail;
13426     {
13427         arg2 = (int)(SWIG_As_int(obj1));
13428         if (SWIG_arg_fail(2)) SWIG_fail;
13429     }
13430     {
13431         PyThreadState* __tstate = wxPyBeginAllowThreads();
13432         (arg1)->SetChooseFull(arg2);
13433
13434         wxPyEndAllowThreads(__tstate);
13435         if (PyErr_Occurred()) SWIG_fail;
13436     }
13437     Py_INCREF(Py_None); resultobj = Py_None;
13438     return resultobj;
13439     fail:
13440     return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_ColourData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13445     PyObject *resultobj;
13446     wxColourData *arg1 = (wxColourData *) 0 ;
13447     wxColour *arg2 = 0 ;
13448     wxColour temp2 ;
13449     PyObject * obj0 = 0 ;
13450     PyObject * obj1 = 0 ;
13451     char *kwnames[] = {
13452         (char *) "self",(char *) "colour", NULL
13453     };
13454
13455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetColour",kwnames,&obj0,&obj1)) goto fail;
13456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13457     if (SWIG_arg_fail(1)) SWIG_fail;
13458     {
13459         arg2 = &temp2;
13460         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13461     }
13462     {
13463         PyThreadState* __tstate = wxPyBeginAllowThreads();
13464         (arg1)->SetColour((wxColour const &)*arg2);
13465
13466         wxPyEndAllowThreads(__tstate);
13467         if (PyErr_Occurred()) SWIG_fail;
13468     }
13469     Py_INCREF(Py_None); resultobj = Py_None;
13470     return resultobj;
13471     fail:
13472     return NULL;
13473 }
13474
13475
13476 static PyObject *_wrap_ColourData_SetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13477     PyObject *resultobj;
13478     wxColourData *arg1 = (wxColourData *) 0 ;
13479     int arg2 ;
13480     wxColour *arg3 = 0 ;
13481     wxColour temp3 ;
13482     PyObject * obj0 = 0 ;
13483     PyObject * obj1 = 0 ;
13484     PyObject * obj2 = 0 ;
13485     char *kwnames[] = {
13486         (char *) "self",(char *) "i",(char *) "colour", NULL
13487     };
13488
13489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourData_SetCustomColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13491     if (SWIG_arg_fail(1)) SWIG_fail;
13492     {
13493         arg2 = (int)(SWIG_As_int(obj1));
13494         if (SWIG_arg_fail(2)) SWIG_fail;
13495     }
13496     {
13497         arg3 = &temp3;
13498         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13499     }
13500     {
13501         PyThreadState* __tstate = wxPyBeginAllowThreads();
13502         (arg1)->SetCustomColour(arg2,(wxColour const &)*arg3);
13503
13504         wxPyEndAllowThreads(__tstate);
13505         if (PyErr_Occurred()) SWIG_fail;
13506     }
13507     Py_INCREF(Py_None); resultobj = Py_None;
13508     return resultobj;
13509     fail:
13510     return NULL;
13511 }
13512
13513
13514 static PyObject * ColourData_swigregister(PyObject *, PyObject *args) {
13515     PyObject *obj;
13516     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13517     SWIG_TypeClientData(SWIGTYPE_p_wxColourData, obj);
13518     Py_INCREF(obj);
13519     return Py_BuildValue((char *)"");
13520 }
13521 static PyObject *_wrap_new_ColourDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13522     PyObject *resultobj;
13523     wxWindow *arg1 = (wxWindow *) 0 ;
13524     wxColourData *arg2 = (wxColourData *) NULL ;
13525     wxColourDialog *result;
13526     PyObject * obj0 = 0 ;
13527     PyObject * obj1 = 0 ;
13528     char *kwnames[] = {
13529         (char *) "parent",(char *) "data", NULL
13530     };
13531
13532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_ColourDialog",kwnames,&obj0,&obj1)) goto fail;
13533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13534     if (SWIG_arg_fail(1)) SWIG_fail;
13535     if (obj1) {
13536         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13537         if (SWIG_arg_fail(2)) SWIG_fail;
13538     }
13539     {
13540         if (!wxPyCheckForApp()) SWIG_fail;
13541         PyThreadState* __tstate = wxPyBeginAllowThreads();
13542         result = (wxColourDialog *)new wxColourDialog(arg1,arg2);
13543
13544         wxPyEndAllowThreads(__tstate);
13545         if (PyErr_Occurred()) SWIG_fail;
13546     }
13547     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDialog, 1);
13548     return resultobj;
13549     fail:
13550     return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_ColourDialog_GetColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13555     PyObject *resultobj;
13556     wxColourDialog *arg1 = (wxColourDialog *) 0 ;
13557     wxColourData *result;
13558     PyObject * obj0 = 0 ;
13559     char *kwnames[] = {
13560         (char *) "self", NULL
13561     };
13562
13563     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourDialog_GetColourData",kwnames,&obj0)) goto fail;
13564     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDialog, SWIG_POINTER_EXCEPTION | 0);
13565     if (SWIG_arg_fail(1)) SWIG_fail;
13566     {
13567         PyThreadState* __tstate = wxPyBeginAllowThreads();
13568         {
13569             wxColourData &_result_ref = (arg1)->GetColourData();
13570             result = (wxColourData *) &_result_ref;
13571         }
13572
13573         wxPyEndAllowThreads(__tstate);
13574         if (PyErr_Occurred()) SWIG_fail;
13575     }
13576     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 0);
13577     return resultobj;
13578     fail:
13579     return NULL;
13580 }
13581
13582
13583 static PyObject * ColourDialog_swigregister(PyObject *, PyObject *args) {
13584     PyObject *obj;
13585     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13586     SWIG_TypeClientData(SWIGTYPE_p_wxColourDialog, obj);
13587     Py_INCREF(obj);
13588     return Py_BuildValue((char *)"");
13589 }
13590 static PyObject *_wrap_new_DirDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13591     PyObject *resultobj;
13592     wxWindow *arg1 = (wxWindow *) 0 ;
13593     wxString const &arg2_defvalue = wxPyDirSelectorPromptStr ;
13594     wxString *arg2 = (wxString *) &arg2_defvalue ;
13595     wxString const &arg3_defvalue = wxPyEmptyString ;
13596     wxString *arg3 = (wxString *) &arg3_defvalue ;
13597     long arg4 = (long) 0 ;
13598     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13599     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13600     wxSize const &arg6_defvalue = wxDefaultSize ;
13601     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13602     wxString const &arg7_defvalue = wxPyDirDialogNameStr ;
13603     wxString *arg7 = (wxString *) &arg7_defvalue ;
13604     wxDirDialog *result;
13605     bool temp2 = false ;
13606     bool temp3 = false ;
13607     wxPoint temp5 ;
13608     wxSize temp6 ;
13609     bool temp7 = false ;
13610     PyObject * obj0 = 0 ;
13611     PyObject * obj1 = 0 ;
13612     PyObject * obj2 = 0 ;
13613     PyObject * obj3 = 0 ;
13614     PyObject * obj4 = 0 ;
13615     PyObject * obj5 = 0 ;
13616     PyObject * obj6 = 0 ;
13617     char *kwnames[] = {
13618         (char *) "parent",(char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL
13619     };
13620
13621     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DirDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13622     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13623     if (SWIG_arg_fail(1)) SWIG_fail;
13624     if (obj1) {
13625         {
13626             arg2 = wxString_in_helper(obj1);
13627             if (arg2 == NULL) SWIG_fail;
13628             temp2 = true;
13629         }
13630     }
13631     if (obj2) {
13632         {
13633             arg3 = wxString_in_helper(obj2);
13634             if (arg3 == NULL) SWIG_fail;
13635             temp3 = true;
13636         }
13637     }
13638     if (obj3) {
13639         {
13640             arg4 = (long)(SWIG_As_long(obj3));
13641             if (SWIG_arg_fail(4)) SWIG_fail;
13642         }
13643     }
13644     if (obj4) {
13645         {
13646             arg5 = &temp5;
13647             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13648         }
13649     }
13650     if (obj5) {
13651         {
13652             arg6 = &temp6;
13653             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13654         }
13655     }
13656     if (obj6) {
13657         {
13658             arg7 = wxString_in_helper(obj6);
13659             if (arg7 == NULL) SWIG_fail;
13660             temp7 = true;
13661         }
13662     }
13663     {
13664         if (!wxPyCheckForApp()) SWIG_fail;
13665         PyThreadState* __tstate = wxPyBeginAllowThreads();
13666         result = (wxDirDialog *)new wxDirDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxString const &)*arg7);
13667
13668         wxPyEndAllowThreads(__tstate);
13669         if (PyErr_Occurred()) SWIG_fail;
13670     }
13671     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirDialog, 1);
13672     {
13673         if (temp2)
13674         delete arg2;
13675     }
13676     {
13677         if (temp3)
13678         delete arg3;
13679     }
13680     {
13681         if (temp7)
13682         delete arg7;
13683     }
13684     return resultobj;
13685     fail:
13686     {
13687         if (temp2)
13688         delete arg2;
13689     }
13690     {
13691         if (temp3)
13692         delete arg3;
13693     }
13694     {
13695         if (temp7)
13696         delete arg7;
13697     }
13698     return NULL;
13699 }
13700
13701
13702 static PyObject *_wrap_DirDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13703     PyObject *resultobj;
13704     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13705     wxString result;
13706     PyObject * obj0 = 0 ;
13707     char *kwnames[] = {
13708         (char *) "self", NULL
13709     };
13710
13711     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetPath",kwnames,&obj0)) goto fail;
13712     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13713     if (SWIG_arg_fail(1)) SWIG_fail;
13714     {
13715         PyThreadState* __tstate = wxPyBeginAllowThreads();
13716         result = (arg1)->GetPath();
13717
13718         wxPyEndAllowThreads(__tstate);
13719         if (PyErr_Occurred()) SWIG_fail;
13720     }
13721     {
13722 #if wxUSE_UNICODE
13723         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13724 #else
13725         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13726 #endif
13727     }
13728     return resultobj;
13729     fail:
13730     return NULL;
13731 }
13732
13733
13734 static PyObject *_wrap_DirDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13735     PyObject *resultobj;
13736     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13737     wxString result;
13738     PyObject * obj0 = 0 ;
13739     char *kwnames[] = {
13740         (char *) "self", NULL
13741     };
13742
13743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetMessage",kwnames,&obj0)) goto fail;
13744     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13745     if (SWIG_arg_fail(1)) SWIG_fail;
13746     {
13747         PyThreadState* __tstate = wxPyBeginAllowThreads();
13748         result = (arg1)->GetMessage();
13749
13750         wxPyEndAllowThreads(__tstate);
13751         if (PyErr_Occurred()) SWIG_fail;
13752     }
13753     {
13754 #if wxUSE_UNICODE
13755         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13756 #else
13757         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13758 #endif
13759     }
13760     return resultobj;
13761     fail:
13762     return NULL;
13763 }
13764
13765
13766 static PyObject *_wrap_DirDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
13767     PyObject *resultobj;
13768     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13769     long result;
13770     PyObject * obj0 = 0 ;
13771     char *kwnames[] = {
13772         (char *) "self", NULL
13773     };
13774
13775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetStyle",kwnames,&obj0)) goto fail;
13776     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13777     if (SWIG_arg_fail(1)) SWIG_fail;
13778     {
13779         PyThreadState* __tstate = wxPyBeginAllowThreads();
13780         result = (long)(arg1)->GetStyle();
13781
13782         wxPyEndAllowThreads(__tstate);
13783         if (PyErr_Occurred()) SWIG_fail;
13784     }
13785     {
13786         resultobj = SWIG_From_long((long)(result));
13787     }
13788     return resultobj;
13789     fail:
13790     return NULL;
13791 }
13792
13793
13794 static PyObject *_wrap_DirDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13795     PyObject *resultobj;
13796     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13797     wxString *arg2 = 0 ;
13798     bool temp2 = false ;
13799     PyObject * obj0 = 0 ;
13800     PyObject * obj1 = 0 ;
13801     char *kwnames[] = {
13802         (char *) "self",(char *) "message", NULL
13803     };
13804
13805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetMessage",kwnames,&obj0,&obj1)) 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         arg2 = wxString_in_helper(obj1);
13810         if (arg2 == NULL) SWIG_fail;
13811         temp2 = true;
13812     }
13813     {
13814         PyThreadState* __tstate = wxPyBeginAllowThreads();
13815         (arg1)->SetMessage((wxString const &)*arg2);
13816
13817         wxPyEndAllowThreads(__tstate);
13818         if (PyErr_Occurred()) SWIG_fail;
13819     }
13820     Py_INCREF(Py_None); resultobj = Py_None;
13821     {
13822         if (temp2)
13823         delete arg2;
13824     }
13825     return resultobj;
13826     fail:
13827     {
13828         if (temp2)
13829         delete arg2;
13830     }
13831     return NULL;
13832 }
13833
13834
13835 static PyObject *_wrap_DirDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13836     PyObject *resultobj;
13837     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13838     wxString *arg2 = 0 ;
13839     bool temp2 = false ;
13840     PyObject * obj0 = 0 ;
13841     PyObject * obj1 = 0 ;
13842     char *kwnames[] = {
13843         (char *) "self",(char *) "path", NULL
13844     };
13845
13846     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
13847     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13848     if (SWIG_arg_fail(1)) SWIG_fail;
13849     {
13850         arg2 = wxString_in_helper(obj1);
13851         if (arg2 == NULL) SWIG_fail;
13852         temp2 = true;
13853     }
13854     {
13855         PyThreadState* __tstate = wxPyBeginAllowThreads();
13856         (arg1)->SetPath((wxString const &)*arg2);
13857
13858         wxPyEndAllowThreads(__tstate);
13859         if (PyErr_Occurred()) SWIG_fail;
13860     }
13861     Py_INCREF(Py_None); resultobj = Py_None;
13862     {
13863         if (temp2)
13864         delete arg2;
13865     }
13866     return resultobj;
13867     fail:
13868     {
13869         if (temp2)
13870         delete arg2;
13871     }
13872     return NULL;
13873 }
13874
13875
13876 static PyObject * DirDialog_swigregister(PyObject *, PyObject *args) {
13877     PyObject *obj;
13878     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13879     SWIG_TypeClientData(SWIGTYPE_p_wxDirDialog, obj);
13880     Py_INCREF(obj);
13881     return Py_BuildValue((char *)"");
13882 }
13883 static PyObject *_wrap_new_FileDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13884     PyObject *resultobj;
13885     wxWindow *arg1 = (wxWindow *) 0 ;
13886     wxString const &arg2_defvalue = wxPyFileSelectorPromptStr ;
13887     wxString *arg2 = (wxString *) &arg2_defvalue ;
13888     wxString const &arg3_defvalue = wxPyEmptyString ;
13889     wxString *arg3 = (wxString *) &arg3_defvalue ;
13890     wxString const &arg4_defvalue = wxPyEmptyString ;
13891     wxString *arg4 = (wxString *) &arg4_defvalue ;
13892     wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
13893     wxString *arg5 = (wxString *) &arg5_defvalue ;
13894     long arg6 = (long) 0 ;
13895     wxPoint const &arg7_defvalue = wxDefaultPosition ;
13896     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
13897     wxFileDialog *result;
13898     bool temp2 = false ;
13899     bool temp3 = false ;
13900     bool temp4 = false ;
13901     bool temp5 = false ;
13902     wxPoint temp7 ;
13903     PyObject * obj0 = 0 ;
13904     PyObject * obj1 = 0 ;
13905     PyObject * obj2 = 0 ;
13906     PyObject * obj3 = 0 ;
13907     PyObject * obj4 = 0 ;
13908     PyObject * obj5 = 0 ;
13909     PyObject * obj6 = 0 ;
13910     char *kwnames[] = {
13911         (char *) "parent",(char *) "message",(char *) "defaultDir",(char *) "defaultFile",(char *) "wildcard",(char *) "style",(char *) "pos", NULL
13912     };
13913
13914     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_FileDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13915     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13916     if (SWIG_arg_fail(1)) SWIG_fail;
13917     if (obj1) {
13918         {
13919             arg2 = wxString_in_helper(obj1);
13920             if (arg2 == NULL) SWIG_fail;
13921             temp2 = true;
13922         }
13923     }
13924     if (obj2) {
13925         {
13926             arg3 = wxString_in_helper(obj2);
13927             if (arg3 == NULL) SWIG_fail;
13928             temp3 = true;
13929         }
13930     }
13931     if (obj3) {
13932         {
13933             arg4 = wxString_in_helper(obj3);
13934             if (arg4 == NULL) SWIG_fail;
13935             temp4 = true;
13936         }
13937     }
13938     if (obj4) {
13939         {
13940             arg5 = wxString_in_helper(obj4);
13941             if (arg5 == NULL) SWIG_fail;
13942             temp5 = true;
13943         }
13944     }
13945     if (obj5) {
13946         {
13947             arg6 = (long)(SWIG_As_long(obj5));
13948             if (SWIG_arg_fail(6)) SWIG_fail;
13949         }
13950     }
13951     if (obj6) {
13952         {
13953             arg7 = &temp7;
13954             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
13955         }
13956     }
13957     {
13958         if (!wxPyCheckForApp()) SWIG_fail;
13959         PyThreadState* __tstate = wxPyBeginAllowThreads();
13960         result = (wxFileDialog *)new wxFileDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,(wxPoint const &)*arg7);
13961
13962         wxPyEndAllowThreads(__tstate);
13963         if (PyErr_Occurred()) SWIG_fail;
13964     }
13965     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDialog, 1);
13966     {
13967         if (temp2)
13968         delete arg2;
13969     }
13970     {
13971         if (temp3)
13972         delete arg3;
13973     }
13974     {
13975         if (temp4)
13976         delete arg4;
13977     }
13978     {
13979         if (temp5)
13980         delete arg5;
13981     }
13982     return resultobj;
13983     fail:
13984     {
13985         if (temp2)
13986         delete arg2;
13987     }
13988     {
13989         if (temp3)
13990         delete arg3;
13991     }
13992     {
13993         if (temp4)
13994         delete arg4;
13995     }
13996     {
13997         if (temp5)
13998         delete arg5;
13999     }
14000     return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_FileDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14005     PyObject *resultobj;
14006     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14007     wxString *arg2 = 0 ;
14008     bool temp2 = false ;
14009     PyObject * obj0 = 0 ;
14010     PyObject * obj1 = 0 ;
14011     char *kwnames[] = {
14012         (char *) "self",(char *) "message", NULL
14013     };
14014
14015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
14016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14017     if (SWIG_arg_fail(1)) SWIG_fail;
14018     {
14019         arg2 = wxString_in_helper(obj1);
14020         if (arg2 == NULL) SWIG_fail;
14021         temp2 = true;
14022     }
14023     {
14024         PyThreadState* __tstate = wxPyBeginAllowThreads();
14025         (arg1)->SetMessage((wxString const &)*arg2);
14026
14027         wxPyEndAllowThreads(__tstate);
14028         if (PyErr_Occurred()) SWIG_fail;
14029     }
14030     Py_INCREF(Py_None); resultobj = Py_None;
14031     {
14032         if (temp2)
14033         delete arg2;
14034     }
14035     return resultobj;
14036     fail:
14037     {
14038         if (temp2)
14039         delete arg2;
14040     }
14041     return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_FileDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14046     PyObject *resultobj;
14047     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14048     wxString *arg2 = 0 ;
14049     bool temp2 = false ;
14050     PyObject * obj0 = 0 ;
14051     PyObject * obj1 = 0 ;
14052     char *kwnames[] = {
14053         (char *) "self",(char *) "path", NULL
14054     };
14055
14056     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
14057     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14058     if (SWIG_arg_fail(1)) SWIG_fail;
14059     {
14060         arg2 = wxString_in_helper(obj1);
14061         if (arg2 == NULL) SWIG_fail;
14062         temp2 = true;
14063     }
14064     {
14065         PyThreadState* __tstate = wxPyBeginAllowThreads();
14066         (arg1)->SetPath((wxString const &)*arg2);
14067
14068         wxPyEndAllowThreads(__tstate);
14069         if (PyErr_Occurred()) SWIG_fail;
14070     }
14071     Py_INCREF(Py_None); resultobj = Py_None;
14072     {
14073         if (temp2)
14074         delete arg2;
14075     }
14076     return resultobj;
14077     fail:
14078     {
14079         if (temp2)
14080         delete arg2;
14081     }
14082     return NULL;
14083 }
14084
14085
14086 static PyObject *_wrap_FileDialog_SetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14087     PyObject *resultobj;
14088     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14089     wxString *arg2 = 0 ;
14090     bool temp2 = false ;
14091     PyObject * obj0 = 0 ;
14092     PyObject * obj1 = 0 ;
14093     char *kwnames[] = {
14094         (char *) "self",(char *) "dir", NULL
14095     };
14096
14097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetDirectory",kwnames,&obj0,&obj1)) goto fail;
14098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14099     if (SWIG_arg_fail(1)) SWIG_fail;
14100     {
14101         arg2 = wxString_in_helper(obj1);
14102         if (arg2 == NULL) SWIG_fail;
14103         temp2 = true;
14104     }
14105     {
14106         PyThreadState* __tstate = wxPyBeginAllowThreads();
14107         (arg1)->SetDirectory((wxString const &)*arg2);
14108
14109         wxPyEndAllowThreads(__tstate);
14110         if (PyErr_Occurred()) SWIG_fail;
14111     }
14112     Py_INCREF(Py_None); resultobj = Py_None;
14113     {
14114         if (temp2)
14115         delete arg2;
14116     }
14117     return resultobj;
14118     fail:
14119     {
14120         if (temp2)
14121         delete arg2;
14122     }
14123     return NULL;
14124 }
14125
14126
14127 static PyObject *_wrap_FileDialog_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14128     PyObject *resultobj;
14129     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14130     wxString *arg2 = 0 ;
14131     bool temp2 = false ;
14132     PyObject * obj0 = 0 ;
14133     PyObject * obj1 = 0 ;
14134     char *kwnames[] = {
14135         (char *) "self",(char *) "name", NULL
14136     };
14137
14138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilename",kwnames,&obj0,&obj1)) goto fail;
14139     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14140     if (SWIG_arg_fail(1)) SWIG_fail;
14141     {
14142         arg2 = wxString_in_helper(obj1);
14143         if (arg2 == NULL) SWIG_fail;
14144         temp2 = true;
14145     }
14146     {
14147         PyThreadState* __tstate = wxPyBeginAllowThreads();
14148         (arg1)->SetFilename((wxString const &)*arg2);
14149
14150         wxPyEndAllowThreads(__tstate);
14151         if (PyErr_Occurred()) SWIG_fail;
14152     }
14153     Py_INCREF(Py_None); resultobj = Py_None;
14154     {
14155         if (temp2)
14156         delete arg2;
14157     }
14158     return resultobj;
14159     fail:
14160     {
14161         if (temp2)
14162         delete arg2;
14163     }
14164     return NULL;
14165 }
14166
14167
14168 static PyObject *_wrap_FileDialog_SetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14169     PyObject *resultobj;
14170     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14171     wxString *arg2 = 0 ;
14172     bool temp2 = false ;
14173     PyObject * obj0 = 0 ;
14174     PyObject * obj1 = 0 ;
14175     char *kwnames[] = {
14176         (char *) "self",(char *) "wildCard", NULL
14177     };
14178
14179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetWildcard",kwnames,&obj0,&obj1)) goto fail;
14180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14181     if (SWIG_arg_fail(1)) SWIG_fail;
14182     {
14183         arg2 = wxString_in_helper(obj1);
14184         if (arg2 == NULL) SWIG_fail;
14185         temp2 = true;
14186     }
14187     {
14188         PyThreadState* __tstate = wxPyBeginAllowThreads();
14189         (arg1)->SetWildcard((wxString const &)*arg2);
14190
14191         wxPyEndAllowThreads(__tstate);
14192         if (PyErr_Occurred()) SWIG_fail;
14193     }
14194     Py_INCREF(Py_None); resultobj = Py_None;
14195     {
14196         if (temp2)
14197         delete arg2;
14198     }
14199     return resultobj;
14200     fail:
14201     {
14202         if (temp2)
14203         delete arg2;
14204     }
14205     return NULL;
14206 }
14207
14208
14209 static PyObject *_wrap_FileDialog_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14210     PyObject *resultobj;
14211     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14212     long arg2 ;
14213     PyObject * obj0 = 0 ;
14214     PyObject * obj1 = 0 ;
14215     char *kwnames[] = {
14216         (char *) "self",(char *) "style", NULL
14217     };
14218
14219     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetStyle",kwnames,&obj0,&obj1)) goto fail;
14220     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14221     if (SWIG_arg_fail(1)) SWIG_fail;
14222     {
14223         arg2 = (long)(SWIG_As_long(obj1));
14224         if (SWIG_arg_fail(2)) SWIG_fail;
14225     }
14226     {
14227         PyThreadState* __tstate = wxPyBeginAllowThreads();
14228         (arg1)->SetStyle(arg2);
14229
14230         wxPyEndAllowThreads(__tstate);
14231         if (PyErr_Occurred()) SWIG_fail;
14232     }
14233     Py_INCREF(Py_None); resultobj = Py_None;
14234     return resultobj;
14235     fail:
14236     return NULL;
14237 }
14238
14239
14240 static PyObject *_wrap_FileDialog_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14241     PyObject *resultobj;
14242     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14243     int arg2 ;
14244     PyObject * obj0 = 0 ;
14245     PyObject * obj1 = 0 ;
14246     char *kwnames[] = {
14247         (char *) "self",(char *) "filterIndex", NULL
14248     };
14249
14250     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
14251     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14252     if (SWIG_arg_fail(1)) SWIG_fail;
14253     {
14254         arg2 = (int)(SWIG_As_int(obj1));
14255         if (SWIG_arg_fail(2)) SWIG_fail;
14256     }
14257     {
14258         PyThreadState* __tstate = wxPyBeginAllowThreads();
14259         (arg1)->SetFilterIndex(arg2);
14260
14261         wxPyEndAllowThreads(__tstate);
14262         if (PyErr_Occurred()) SWIG_fail;
14263     }
14264     Py_INCREF(Py_None); resultobj = Py_None;
14265     return resultobj;
14266     fail:
14267     return NULL;
14268 }
14269
14270
14271 static PyObject *_wrap_FileDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14272     PyObject *resultobj;
14273     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14274     wxString result;
14275     PyObject * obj0 = 0 ;
14276     char *kwnames[] = {
14277         (char *) "self", NULL
14278     };
14279
14280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetMessage",kwnames,&obj0)) goto fail;
14281     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14282     if (SWIG_arg_fail(1)) SWIG_fail;
14283     {
14284         PyThreadState* __tstate = wxPyBeginAllowThreads();
14285         result = ((wxFileDialog const *)arg1)->GetMessage();
14286
14287         wxPyEndAllowThreads(__tstate);
14288         if (PyErr_Occurred()) SWIG_fail;
14289     }
14290     {
14291 #if wxUSE_UNICODE
14292         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14293 #else
14294         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14295 #endif
14296     }
14297     return resultobj;
14298     fail:
14299     return NULL;
14300 }
14301
14302
14303 static PyObject *_wrap_FileDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14304     PyObject *resultobj;
14305     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14306     wxString result;
14307     PyObject * obj0 = 0 ;
14308     char *kwnames[] = {
14309         (char *) "self", NULL
14310     };
14311
14312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPath",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
14317         result = ((wxFileDialog const *)arg1)->GetPath();
14318
14319         wxPyEndAllowThreads(__tstate);
14320         if (PyErr_Occurred()) SWIG_fail;
14321     }
14322     {
14323 #if wxUSE_UNICODE
14324         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14325 #else
14326         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14327 #endif
14328     }
14329     return resultobj;
14330     fail:
14331     return NULL;
14332 }
14333
14334
14335 static PyObject *_wrap_FileDialog_GetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14336     PyObject *resultobj;
14337     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14338     wxString result;
14339     PyObject * obj0 = 0 ;
14340     char *kwnames[] = {
14341         (char *) "self", NULL
14342     };
14343
14344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetDirectory",kwnames,&obj0)) goto fail;
14345     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14346     if (SWIG_arg_fail(1)) SWIG_fail;
14347     {
14348         PyThreadState* __tstate = wxPyBeginAllowThreads();
14349         result = ((wxFileDialog const *)arg1)->GetDirectory();
14350
14351         wxPyEndAllowThreads(__tstate);
14352         if (PyErr_Occurred()) SWIG_fail;
14353     }
14354     {
14355 #if wxUSE_UNICODE
14356         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14357 #else
14358         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14359 #endif
14360     }
14361     return resultobj;
14362     fail:
14363     return NULL;
14364 }
14365
14366
14367 static PyObject *_wrap_FileDialog_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14368     PyObject *resultobj;
14369     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14370     wxString result;
14371     PyObject * obj0 = 0 ;
14372     char *kwnames[] = {
14373         (char *) "self", NULL
14374     };
14375
14376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilename",kwnames,&obj0)) goto fail;
14377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14378     if (SWIG_arg_fail(1)) SWIG_fail;
14379     {
14380         PyThreadState* __tstate = wxPyBeginAllowThreads();
14381         result = ((wxFileDialog const *)arg1)->GetFilename();
14382
14383         wxPyEndAllowThreads(__tstate);
14384         if (PyErr_Occurred()) SWIG_fail;
14385     }
14386     {
14387 #if wxUSE_UNICODE
14388         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14389 #else
14390         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14391 #endif
14392     }
14393     return resultobj;
14394     fail:
14395     return NULL;
14396 }
14397
14398
14399 static PyObject *_wrap_FileDialog_GetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14400     PyObject *resultobj;
14401     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14402     wxString result;
14403     PyObject * obj0 = 0 ;
14404     char *kwnames[] = {
14405         (char *) "self", NULL
14406     };
14407
14408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetWildcard",kwnames,&obj0)) goto fail;
14409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14410     if (SWIG_arg_fail(1)) SWIG_fail;
14411     {
14412         PyThreadState* __tstate = wxPyBeginAllowThreads();
14413         result = ((wxFileDialog const *)arg1)->GetWildcard();
14414
14415         wxPyEndAllowThreads(__tstate);
14416         if (PyErr_Occurred()) SWIG_fail;
14417     }
14418     {
14419 #if wxUSE_UNICODE
14420         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14421 #else
14422         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14423 #endif
14424     }
14425     return resultobj;
14426     fail:
14427     return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_FileDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14432     PyObject *resultobj;
14433     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14434     long result;
14435     PyObject * obj0 = 0 ;
14436     char *kwnames[] = {
14437         (char *) "self", NULL
14438     };
14439
14440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetStyle",kwnames,&obj0)) goto fail;
14441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14442     if (SWIG_arg_fail(1)) SWIG_fail;
14443     {
14444         PyThreadState* __tstate = wxPyBeginAllowThreads();
14445         result = (long)((wxFileDialog const *)arg1)->GetStyle();
14446
14447         wxPyEndAllowThreads(__tstate);
14448         if (PyErr_Occurred()) SWIG_fail;
14449     }
14450     {
14451         resultobj = SWIG_From_long((long)(result));
14452     }
14453     return resultobj;
14454     fail:
14455     return NULL;
14456 }
14457
14458
14459 static PyObject *_wrap_FileDialog_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14460     PyObject *resultobj;
14461     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14462     int result;
14463     PyObject * obj0 = 0 ;
14464     char *kwnames[] = {
14465         (char *) "self", NULL
14466     };
14467
14468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilterIndex",kwnames,&obj0)) goto fail;
14469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14470     if (SWIG_arg_fail(1)) SWIG_fail;
14471     {
14472         PyThreadState* __tstate = wxPyBeginAllowThreads();
14473         result = (int)((wxFileDialog const *)arg1)->GetFilterIndex();
14474
14475         wxPyEndAllowThreads(__tstate);
14476         if (PyErr_Occurred()) SWIG_fail;
14477     }
14478     {
14479         resultobj = SWIG_From_int((int)(result));
14480     }
14481     return resultobj;
14482     fail:
14483     return NULL;
14484 }
14485
14486
14487 static PyObject *_wrap_FileDialog_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
14488     PyObject *resultobj;
14489     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14490     PyObject *result;
14491     PyObject * obj0 = 0 ;
14492     char *kwnames[] = {
14493         (char *) "self", NULL
14494     };
14495
14496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilenames",kwnames,&obj0)) goto fail;
14497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14498     if (SWIG_arg_fail(1)) SWIG_fail;
14499     {
14500         PyThreadState* __tstate = wxPyBeginAllowThreads();
14501         result = (PyObject *)wxFileDialog_GetFilenames(arg1);
14502
14503         wxPyEndAllowThreads(__tstate);
14504         if (PyErr_Occurred()) SWIG_fail;
14505     }
14506     resultobj = result;
14507     return resultobj;
14508     fail:
14509     return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_FileDialog_GetPaths(PyObject *, PyObject *args, PyObject *kwargs) {
14514     PyObject *resultobj;
14515     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14516     PyObject *result;
14517     PyObject * obj0 = 0 ;
14518     char *kwnames[] = {
14519         (char *) "self", NULL
14520     };
14521
14522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPaths",kwnames,&obj0)) goto fail;
14523     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14524     if (SWIG_arg_fail(1)) SWIG_fail;
14525     {
14526         PyThreadState* __tstate = wxPyBeginAllowThreads();
14527         result = (PyObject *)wxFileDialog_GetPaths(arg1);
14528
14529         wxPyEndAllowThreads(__tstate);
14530         if (PyErr_Occurred()) SWIG_fail;
14531     }
14532     resultobj = result;
14533     return resultobj;
14534     fail:
14535     return NULL;
14536 }
14537
14538
14539 static PyObject * FileDialog_swigregister(PyObject *, PyObject *args) {
14540     PyObject *obj;
14541     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14542     SWIG_TypeClientData(SWIGTYPE_p_wxFileDialog, obj);
14543     Py_INCREF(obj);
14544     return Py_BuildValue((char *)"");
14545 }
14546 static PyObject *_wrap_new_MultiChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14547     PyObject *resultobj;
14548     wxWindow *arg1 = (wxWindow *) 0 ;
14549     wxString *arg2 = 0 ;
14550     wxString *arg3 = 0 ;
14551     int arg4 = (int) 0 ;
14552     wxString *arg5 = (wxString *) NULL ;
14553     long arg6 = (long) wxCHOICEDLG_STYLE ;
14554     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14555     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14556     wxMultiChoiceDialog *result;
14557     bool temp2 = false ;
14558     bool temp3 = false ;
14559     wxPoint temp7 ;
14560     PyObject * obj0 = 0 ;
14561     PyObject * obj1 = 0 ;
14562     PyObject * obj2 = 0 ;
14563     PyObject * obj3 = 0 ;
14564     PyObject * obj4 = 0 ;
14565     PyObject * obj5 = 0 ;
14566     char *kwnames[] = {
14567         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14568     };
14569
14570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_MultiChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14572     if (SWIG_arg_fail(1)) SWIG_fail;
14573     {
14574         arg2 = wxString_in_helper(obj1);
14575         if (arg2 == NULL) SWIG_fail;
14576         temp2 = true;
14577     }
14578     {
14579         arg3 = wxString_in_helper(obj2);
14580         if (arg3 == NULL) SWIG_fail;
14581         temp3 = true;
14582     }
14583     if (obj3) {
14584         {
14585             arg4 = PyList_Size(obj3);
14586             arg5 = wxString_LIST_helper(obj3);
14587             if (arg5 == NULL) SWIG_fail;
14588         }
14589     }
14590     if (obj4) {
14591         {
14592             arg6 = (long)(SWIG_As_long(obj4));
14593             if (SWIG_arg_fail(6)) SWIG_fail;
14594         }
14595     }
14596     if (obj5) {
14597         {
14598             arg7 = &temp7;
14599             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14600         }
14601     }
14602     {
14603         if (!wxPyCheckForApp()) SWIG_fail;
14604         PyThreadState* __tstate = wxPyBeginAllowThreads();
14605         result = (wxMultiChoiceDialog *)new wxMultiChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14606
14607         wxPyEndAllowThreads(__tstate);
14608         if (PyErr_Occurred()) SWIG_fail;
14609     }
14610     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMultiChoiceDialog, 1);
14611     {
14612         if (temp2)
14613         delete arg2;
14614     }
14615     {
14616         if (temp3)
14617         delete arg3;
14618     }
14619     {
14620         if (arg5) delete [] arg5;
14621     }
14622     return resultobj;
14623     fail:
14624     {
14625         if (temp2)
14626         delete arg2;
14627     }
14628     {
14629         if (temp3)
14630         delete arg3;
14631     }
14632     {
14633         if (arg5) delete [] arg5;
14634     }
14635     return NULL;
14636 }
14637
14638
14639 static PyObject *_wrap_MultiChoiceDialog_SetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14640     PyObject *resultobj;
14641     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14642     wxArrayInt *arg2 = 0 ;
14643     bool temp2 = false ;
14644     PyObject * obj0 = 0 ;
14645     PyObject * obj1 = 0 ;
14646     char *kwnames[] = {
14647         (char *) "self",(char *) "selections", NULL
14648     };
14649
14650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MultiChoiceDialog_SetSelections",kwnames,&obj0,&obj1)) goto fail;
14651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14652     if (SWIG_arg_fail(1)) SWIG_fail;
14653     {
14654         if (! PySequence_Check(obj1)) {
14655             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
14656             SWIG_fail;
14657         }
14658         arg2 = new wxArrayInt;
14659         temp2 = true;
14660         int i, len=PySequence_Length(obj1);
14661         for (i=0; i<len; i++) {
14662             PyObject* item = PySequence_GetItem(obj1, i);
14663             PyObject* number  = PyNumber_Int(item);
14664             arg2->Add(PyInt_AS_LONG(number));
14665             Py_DECREF(item);
14666             Py_DECREF(number);
14667         }
14668     }
14669     {
14670         PyThreadState* __tstate = wxPyBeginAllowThreads();
14671         (arg1)->SetSelections((wxArrayInt const &)*arg2);
14672
14673         wxPyEndAllowThreads(__tstate);
14674         if (PyErr_Occurred()) SWIG_fail;
14675     }
14676     Py_INCREF(Py_None); resultobj = Py_None;
14677     {
14678         if (temp2) delete arg2;
14679     }
14680     return resultobj;
14681     fail:
14682     {
14683         if (temp2) delete arg2;
14684     }
14685     return NULL;
14686 }
14687
14688
14689 static PyObject *_wrap_MultiChoiceDialog_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14690     PyObject *resultobj;
14691     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14692     PyObject *result;
14693     PyObject * obj0 = 0 ;
14694     char *kwnames[] = {
14695         (char *) "self", NULL
14696     };
14697
14698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MultiChoiceDialog_GetSelections",kwnames,&obj0)) goto fail;
14699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14700     if (SWIG_arg_fail(1)) SWIG_fail;
14701     {
14702         PyThreadState* __tstate = wxPyBeginAllowThreads();
14703         result = (PyObject *)wxMultiChoiceDialog_GetSelections(arg1);
14704
14705         wxPyEndAllowThreads(__tstate);
14706         if (PyErr_Occurred()) SWIG_fail;
14707     }
14708     resultobj = result;
14709     return resultobj;
14710     fail:
14711     return NULL;
14712 }
14713
14714
14715 static PyObject * MultiChoiceDialog_swigregister(PyObject *, PyObject *args) {
14716     PyObject *obj;
14717     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14718     SWIG_TypeClientData(SWIGTYPE_p_wxMultiChoiceDialog, obj);
14719     Py_INCREF(obj);
14720     return Py_BuildValue((char *)"");
14721 }
14722 static PyObject *_wrap_new_SingleChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14723     PyObject *resultobj;
14724     wxWindow *arg1 = (wxWindow *) 0 ;
14725     wxString *arg2 = 0 ;
14726     wxString *arg3 = 0 ;
14727     int arg4 ;
14728     wxString *arg5 = (wxString *) 0 ;
14729     long arg6 = (long) wxCHOICEDLG_STYLE ;
14730     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14731     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14732     wxSingleChoiceDialog *result;
14733     bool temp2 = false ;
14734     bool temp3 = false ;
14735     wxPoint temp7 ;
14736     PyObject * obj0 = 0 ;
14737     PyObject * obj1 = 0 ;
14738     PyObject * obj2 = 0 ;
14739     PyObject * obj3 = 0 ;
14740     PyObject * obj4 = 0 ;
14741     PyObject * obj5 = 0 ;
14742     char *kwnames[] = {
14743         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14744     };
14745
14746     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:new_SingleChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14747     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14748     if (SWIG_arg_fail(1)) SWIG_fail;
14749     {
14750         arg2 = wxString_in_helper(obj1);
14751         if (arg2 == NULL) SWIG_fail;
14752         temp2 = true;
14753     }
14754     {
14755         arg3 = wxString_in_helper(obj2);
14756         if (arg3 == NULL) SWIG_fail;
14757         temp3 = true;
14758     }
14759     {
14760         arg4 = PyList_Size(obj3);
14761         arg5 = wxString_LIST_helper(obj3);
14762         if (arg5 == NULL) SWIG_fail;
14763     }
14764     if (obj4) {
14765         {
14766             arg6 = (long)(SWIG_As_long(obj4));
14767             if (SWIG_arg_fail(6)) SWIG_fail;
14768         }
14769     }
14770     if (obj5) {
14771         {
14772             arg7 = &temp7;
14773             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14774         }
14775     }
14776     {
14777         if (!wxPyCheckForApp()) SWIG_fail;
14778         PyThreadState* __tstate = wxPyBeginAllowThreads();
14779         result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14780
14781         wxPyEndAllowThreads(__tstate);
14782         if (PyErr_Occurred()) SWIG_fail;
14783     }
14784     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleChoiceDialog, 1);
14785     {
14786         if (temp2)
14787         delete arg2;
14788     }
14789     {
14790         if (temp3)
14791         delete arg3;
14792     }
14793     {
14794         if (arg5) delete [] arg5;
14795     }
14796     return resultobj;
14797     fail:
14798     {
14799         if (temp2)
14800         delete arg2;
14801     }
14802     {
14803         if (temp3)
14804         delete arg3;
14805     }
14806     {
14807         if (arg5) delete [] arg5;
14808     }
14809     return NULL;
14810 }
14811
14812
14813 static PyObject *_wrap_SingleChoiceDialog_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14814     PyObject *resultobj;
14815     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14816     int result;
14817     PyObject * obj0 = 0 ;
14818     char *kwnames[] = {
14819         (char *) "self", NULL
14820     };
14821
14822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetSelection",kwnames,&obj0)) goto fail;
14823     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14824     if (SWIG_arg_fail(1)) SWIG_fail;
14825     {
14826         PyThreadState* __tstate = wxPyBeginAllowThreads();
14827         result = (int)(arg1)->GetSelection();
14828
14829         wxPyEndAllowThreads(__tstate);
14830         if (PyErr_Occurred()) SWIG_fail;
14831     }
14832     {
14833         resultobj = SWIG_From_int((int)(result));
14834     }
14835     return resultobj;
14836     fail:
14837     return NULL;
14838 }
14839
14840
14841 static PyObject *_wrap_SingleChoiceDialog_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14842     PyObject *resultobj;
14843     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14844     wxString result;
14845     PyObject * obj0 = 0 ;
14846     char *kwnames[] = {
14847         (char *) "self", NULL
14848     };
14849
14850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetStringSelection",kwnames,&obj0)) goto fail;
14851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14852     if (SWIG_arg_fail(1)) SWIG_fail;
14853     {
14854         PyThreadState* __tstate = wxPyBeginAllowThreads();
14855         result = (arg1)->GetStringSelection();
14856
14857         wxPyEndAllowThreads(__tstate);
14858         if (PyErr_Occurred()) SWIG_fail;
14859     }
14860     {
14861 #if wxUSE_UNICODE
14862         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14863 #else
14864         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14865 #endif
14866     }
14867     return resultobj;
14868     fail:
14869     return NULL;
14870 }
14871
14872
14873 static PyObject *_wrap_SingleChoiceDialog_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14874     PyObject *resultobj;
14875     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14876     int arg2 ;
14877     PyObject * obj0 = 0 ;
14878     PyObject * obj1 = 0 ;
14879     char *kwnames[] = {
14880         (char *) "self",(char *) "sel", NULL
14881     };
14882
14883     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SingleChoiceDialog_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14884     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14885     if (SWIG_arg_fail(1)) SWIG_fail;
14886     {
14887         arg2 = (int)(SWIG_As_int(obj1));
14888         if (SWIG_arg_fail(2)) SWIG_fail;
14889     }
14890     {
14891         PyThreadState* __tstate = wxPyBeginAllowThreads();
14892         (arg1)->SetSelection(arg2);
14893
14894         wxPyEndAllowThreads(__tstate);
14895         if (PyErr_Occurred()) SWIG_fail;
14896     }
14897     Py_INCREF(Py_None); resultobj = Py_None;
14898     return resultobj;
14899     fail:
14900     return NULL;
14901 }
14902
14903
14904 static PyObject * SingleChoiceDialog_swigregister(PyObject *, PyObject *args) {
14905     PyObject *obj;
14906     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14907     SWIG_TypeClientData(SWIGTYPE_p_wxSingleChoiceDialog, obj);
14908     Py_INCREF(obj);
14909     return Py_BuildValue((char *)"");
14910 }
14911 static PyObject *_wrap_new_TextEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14912     PyObject *resultobj;
14913     wxWindow *arg1 = (wxWindow *) 0 ;
14914     wxString *arg2 = 0 ;
14915     wxString const &arg3_defvalue = wxPyGetTextFromUserPromptStr ;
14916     wxString *arg3 = (wxString *) &arg3_defvalue ;
14917     wxString const &arg4_defvalue = wxPyEmptyString ;
14918     wxString *arg4 = (wxString *) &arg4_defvalue ;
14919     long arg5 = (long) wxTextEntryDialogStyle ;
14920     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14921     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14922     wxTextEntryDialog *result;
14923     bool temp2 = false ;
14924     bool temp3 = false ;
14925     bool temp4 = false ;
14926     wxPoint temp6 ;
14927     PyObject * obj0 = 0 ;
14928     PyObject * obj1 = 0 ;
14929     PyObject * obj2 = 0 ;
14930     PyObject * obj3 = 0 ;
14931     PyObject * obj4 = 0 ;
14932     PyObject * obj5 = 0 ;
14933     char *kwnames[] = {
14934         (char *) "parent",(char *) "message",(char *) "caption",(char *) "defaultValue",(char *) "style",(char *) "pos", NULL
14935     };
14936
14937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_TextEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14939     if (SWIG_arg_fail(1)) SWIG_fail;
14940     {
14941         arg2 = wxString_in_helper(obj1);
14942         if (arg2 == NULL) SWIG_fail;
14943         temp2 = true;
14944     }
14945     if (obj2) {
14946         {
14947             arg3 = wxString_in_helper(obj2);
14948             if (arg3 == NULL) SWIG_fail;
14949             temp3 = true;
14950         }
14951     }
14952     if (obj3) {
14953         {
14954             arg4 = wxString_in_helper(obj3);
14955             if (arg4 == NULL) SWIG_fail;
14956             temp4 = true;
14957         }
14958     }
14959     if (obj4) {
14960         {
14961             arg5 = (long)(SWIG_As_long(obj4));
14962             if (SWIG_arg_fail(5)) SWIG_fail;
14963         }
14964     }
14965     if (obj5) {
14966         {
14967             arg6 = &temp6;
14968             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
14969         }
14970     }
14971     {
14972         if (!wxPyCheckForApp()) SWIG_fail;
14973         PyThreadState* __tstate = wxPyBeginAllowThreads();
14974         result = (wxTextEntryDialog *)new wxTextEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
14975
14976         wxPyEndAllowThreads(__tstate);
14977         if (PyErr_Occurred()) SWIG_fail;
14978     }
14979     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextEntryDialog, 1);
14980     {
14981         if (temp2)
14982         delete arg2;
14983     }
14984     {
14985         if (temp3)
14986         delete arg3;
14987     }
14988     {
14989         if (temp4)
14990         delete arg4;
14991     }
14992     return resultobj;
14993     fail:
14994     {
14995         if (temp2)
14996         delete arg2;
14997     }
14998     {
14999         if (temp3)
15000         delete arg3;
15001     }
15002     {
15003         if (temp4)
15004         delete arg4;
15005     }
15006     return NULL;
15007 }
15008
15009
15010 static PyObject *_wrap_TextEntryDialog_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15011     PyObject *resultobj;
15012     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15013     wxString result;
15014     PyObject * obj0 = 0 ;
15015     char *kwnames[] = {
15016         (char *) "self", NULL
15017     };
15018
15019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextEntryDialog_GetValue",kwnames,&obj0)) goto fail;
15020     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15021     if (SWIG_arg_fail(1)) SWIG_fail;
15022     {
15023         PyThreadState* __tstate = wxPyBeginAllowThreads();
15024         result = (arg1)->GetValue();
15025
15026         wxPyEndAllowThreads(__tstate);
15027         if (PyErr_Occurred()) SWIG_fail;
15028     }
15029     {
15030 #if wxUSE_UNICODE
15031         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15032 #else
15033         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15034 #endif
15035     }
15036     return resultobj;
15037     fail:
15038     return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_TextEntryDialog_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15043     PyObject *resultobj;
15044     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15045     wxString *arg2 = 0 ;
15046     bool temp2 = false ;
15047     PyObject * obj0 = 0 ;
15048     PyObject * obj1 = 0 ;
15049     char *kwnames[] = {
15050         (char *) "self",(char *) "value", NULL
15051     };
15052
15053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextEntryDialog_SetValue",kwnames,&obj0,&obj1)) goto fail;
15054     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15055     if (SWIG_arg_fail(1)) SWIG_fail;
15056     {
15057         arg2 = wxString_in_helper(obj1);
15058         if (arg2 == NULL) SWIG_fail;
15059         temp2 = true;
15060     }
15061     {
15062         PyThreadState* __tstate = wxPyBeginAllowThreads();
15063         (arg1)->SetValue((wxString const &)*arg2);
15064
15065         wxPyEndAllowThreads(__tstate);
15066         if (PyErr_Occurred()) SWIG_fail;
15067     }
15068     Py_INCREF(Py_None); resultobj = Py_None;
15069     {
15070         if (temp2)
15071         delete arg2;
15072     }
15073     return resultobj;
15074     fail:
15075     {
15076         if (temp2)
15077         delete arg2;
15078     }
15079     return NULL;
15080 }
15081
15082
15083 static PyObject * TextEntryDialog_swigregister(PyObject *, PyObject *args) {
15084     PyObject *obj;
15085     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15086     SWIG_TypeClientData(SWIGTYPE_p_wxTextEntryDialog, obj);
15087     Py_INCREF(obj);
15088     return Py_BuildValue((char *)"");
15089 }
15090 static int _wrap_GetPasswordFromUserPromptStr_set(PyObject *) {
15091     PyErr_SetString(PyExc_TypeError,"Variable GetPasswordFromUserPromptStr is read-only.");
15092     return 1;
15093 }
15094
15095
15096 static PyObject *_wrap_GetPasswordFromUserPromptStr_get(void) {
15097     PyObject *pyobj;
15098
15099     {
15100 #if wxUSE_UNICODE
15101         pyobj = PyUnicode_FromWideChar((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15102 #else
15103         pyobj = PyString_FromStringAndSize((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15104 #endif
15105     }
15106     return pyobj;
15107 }
15108
15109
15110 static PyObject *_wrap_new_PasswordEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15111     PyObject *resultobj;
15112     wxWindow *arg1 = (wxWindow *) 0 ;
15113     wxString *arg2 = 0 ;
15114     wxString const &arg3_defvalue = wxPyGetPasswordFromUserPromptStr ;
15115     wxString *arg3 = (wxString *) &arg3_defvalue ;
15116     wxString const &arg4_defvalue = wxPyEmptyString ;
15117     wxString *arg4 = (wxString *) &arg4_defvalue ;
15118     long arg5 = (long) wxTextEntryDialogStyle ;
15119     wxPoint const &arg6_defvalue = wxDefaultPosition ;
15120     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
15121     wxPasswordEntryDialog *result;
15122     bool temp2 = false ;
15123     bool temp3 = false ;
15124     bool temp4 = false ;
15125     wxPoint temp6 ;
15126     PyObject * obj0 = 0 ;
15127     PyObject * obj1 = 0 ;
15128     PyObject * obj2 = 0 ;
15129     PyObject * obj3 = 0 ;
15130     PyObject * obj4 = 0 ;
15131     PyObject * obj5 = 0 ;
15132     char *kwnames[] = {
15133         (char *) "parent",(char *) "message",(char *) "caption",(char *) "value",(char *) "style",(char *) "pos", NULL
15134     };
15135
15136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PasswordEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15138     if (SWIG_arg_fail(1)) SWIG_fail;
15139     {
15140         arg2 = wxString_in_helper(obj1);
15141         if (arg2 == NULL) SWIG_fail;
15142         temp2 = true;
15143     }
15144     if (obj2) {
15145         {
15146             arg3 = wxString_in_helper(obj2);
15147             if (arg3 == NULL) SWIG_fail;
15148             temp3 = true;
15149         }
15150     }
15151     if (obj3) {
15152         {
15153             arg4 = wxString_in_helper(obj3);
15154             if (arg4 == NULL) SWIG_fail;
15155             temp4 = true;
15156         }
15157     }
15158     if (obj4) {
15159         {
15160             arg5 = (long)(SWIG_As_long(obj4));
15161             if (SWIG_arg_fail(5)) SWIG_fail;
15162         }
15163     }
15164     if (obj5) {
15165         {
15166             arg6 = &temp6;
15167             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15168         }
15169     }
15170     {
15171         PyThreadState* __tstate = wxPyBeginAllowThreads();
15172         result = (wxPasswordEntryDialog *)new wxPasswordEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15173
15174         wxPyEndAllowThreads(__tstate);
15175         if (PyErr_Occurred()) SWIG_fail;
15176     }
15177     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPasswordEntryDialog, 1);
15178     {
15179         if (temp2)
15180         delete arg2;
15181     }
15182     {
15183         if (temp3)
15184         delete arg3;
15185     }
15186     {
15187         if (temp4)
15188         delete arg4;
15189     }
15190     return resultobj;
15191     fail:
15192     {
15193         if (temp2)
15194         delete arg2;
15195     }
15196     {
15197         if (temp3)
15198         delete arg3;
15199     }
15200     {
15201         if (temp4)
15202         delete arg4;
15203     }
15204     return NULL;
15205 }
15206
15207
15208 static PyObject * PasswordEntryDialog_swigregister(PyObject *, PyObject *args) {
15209     PyObject *obj;
15210     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15211     SWIG_TypeClientData(SWIGTYPE_p_wxPasswordEntryDialog, obj);
15212     Py_INCREF(obj);
15213     return Py_BuildValue((char *)"");
15214 }
15215 static PyObject *_wrap_new_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15216     PyObject *resultobj;
15217     wxFontData *result;
15218     char *kwnames[] = {
15219         NULL
15220     };
15221
15222     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontData",kwnames)) goto fail;
15223     {
15224         PyThreadState* __tstate = wxPyBeginAllowThreads();
15225         result = (wxFontData *)new wxFontData();
15226
15227         wxPyEndAllowThreads(__tstate);
15228         if (PyErr_Occurred()) SWIG_fail;
15229     }
15230     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 1);
15231     return resultobj;
15232     fail:
15233     return NULL;
15234 }
15235
15236
15237 static PyObject *_wrap_delete_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15238     PyObject *resultobj;
15239     wxFontData *arg1 = (wxFontData *) 0 ;
15240     PyObject * obj0 = 0 ;
15241     char *kwnames[] = {
15242         (char *) "self", NULL
15243     };
15244
15245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontData",kwnames,&obj0)) goto fail;
15246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15247     if (SWIG_arg_fail(1)) SWIG_fail;
15248     {
15249         PyThreadState* __tstate = wxPyBeginAllowThreads();
15250         delete arg1;
15251
15252         wxPyEndAllowThreads(__tstate);
15253         if (PyErr_Occurred()) SWIG_fail;
15254     }
15255     Py_INCREF(Py_None); resultobj = Py_None;
15256     return resultobj;
15257     fail:
15258     return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_FontData_EnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15263     PyObject *resultobj;
15264     wxFontData *arg1 = (wxFontData *) 0 ;
15265     bool arg2 ;
15266     PyObject * obj0 = 0 ;
15267     PyObject * obj1 = 0 ;
15268     char *kwnames[] = {
15269         (char *) "self",(char *) "enable", NULL
15270     };
15271
15272     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_EnableEffects",kwnames,&obj0,&obj1)) goto fail;
15273     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15274     if (SWIG_arg_fail(1)) SWIG_fail;
15275     {
15276         arg2 = (bool)(SWIG_As_bool(obj1));
15277         if (SWIG_arg_fail(2)) SWIG_fail;
15278     }
15279     {
15280         PyThreadState* __tstate = wxPyBeginAllowThreads();
15281         (arg1)->EnableEffects(arg2);
15282
15283         wxPyEndAllowThreads(__tstate);
15284         if (PyErr_Occurred()) SWIG_fail;
15285     }
15286     Py_INCREF(Py_None); resultobj = Py_None;
15287     return resultobj;
15288     fail:
15289     return NULL;
15290 }
15291
15292
15293 static PyObject *_wrap_FontData_GetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15294     PyObject *resultobj;
15295     wxFontData *arg1 = (wxFontData *) 0 ;
15296     bool result;
15297     PyObject * obj0 = 0 ;
15298     char *kwnames[] = {
15299         (char *) "self", NULL
15300     };
15301
15302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetAllowSymbols",kwnames,&obj0)) goto fail;
15303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15304     if (SWIG_arg_fail(1)) SWIG_fail;
15305     {
15306         PyThreadState* __tstate = wxPyBeginAllowThreads();
15307         result = (bool)(arg1)->GetAllowSymbols();
15308
15309         wxPyEndAllowThreads(__tstate);
15310         if (PyErr_Occurred()) SWIG_fail;
15311     }
15312     {
15313         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15314     }
15315     return resultobj;
15316     fail:
15317     return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_FontData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15322     PyObject *resultobj;
15323     wxFontData *arg1 = (wxFontData *) 0 ;
15324     wxColour result;
15325     PyObject * obj0 = 0 ;
15326     char *kwnames[] = {
15327         (char *) "self", NULL
15328     };
15329
15330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetColour",kwnames,&obj0)) goto fail;
15331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15332     if (SWIG_arg_fail(1)) SWIG_fail;
15333     {
15334         PyThreadState* __tstate = wxPyBeginAllowThreads();
15335         result = (arg1)->GetColour();
15336
15337         wxPyEndAllowThreads(__tstate);
15338         if (PyErr_Occurred()) SWIG_fail;
15339     }
15340     {
15341         wxColour * resultptr;
15342         resultptr = new wxColour((wxColour &)(result));
15343         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15344     }
15345     return resultobj;
15346     fail:
15347     return NULL;
15348 }
15349
15350
15351 static PyObject *_wrap_FontData_GetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15352     PyObject *resultobj;
15353     wxFontData *arg1 = (wxFontData *) 0 ;
15354     wxFont result;
15355     PyObject * obj0 = 0 ;
15356     char *kwnames[] = {
15357         (char *) "self", NULL
15358     };
15359
15360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetChosenFont",kwnames,&obj0)) goto fail;
15361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15362     if (SWIG_arg_fail(1)) SWIG_fail;
15363     {
15364         PyThreadState* __tstate = wxPyBeginAllowThreads();
15365         result = (arg1)->GetChosenFont();
15366
15367         wxPyEndAllowThreads(__tstate);
15368         if (PyErr_Occurred()) SWIG_fail;
15369     }
15370     {
15371         wxFont * resultptr;
15372         resultptr = new wxFont((wxFont &)(result));
15373         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15374     }
15375     return resultobj;
15376     fail:
15377     return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_FontData_GetEnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15382     PyObject *resultobj;
15383     wxFontData *arg1 = (wxFontData *) 0 ;
15384     bool result;
15385     PyObject * obj0 = 0 ;
15386     char *kwnames[] = {
15387         (char *) "self", NULL
15388     };
15389
15390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetEnableEffects",kwnames,&obj0)) goto fail;
15391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15392     if (SWIG_arg_fail(1)) SWIG_fail;
15393     {
15394         PyThreadState* __tstate = wxPyBeginAllowThreads();
15395         result = (bool)(arg1)->GetEnableEffects();
15396
15397         wxPyEndAllowThreads(__tstate);
15398         if (PyErr_Occurred()) SWIG_fail;
15399     }
15400     {
15401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15402     }
15403     return resultobj;
15404     fail:
15405     return NULL;
15406 }
15407
15408
15409 static PyObject *_wrap_FontData_GetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15410     PyObject *resultobj;
15411     wxFontData *arg1 = (wxFontData *) 0 ;
15412     wxFont result;
15413     PyObject * obj0 = 0 ;
15414     char *kwnames[] = {
15415         (char *) "self", NULL
15416     };
15417
15418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetInitialFont",kwnames,&obj0)) goto fail;
15419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15420     if (SWIG_arg_fail(1)) SWIG_fail;
15421     {
15422         PyThreadState* __tstate = wxPyBeginAllowThreads();
15423         result = (arg1)->GetInitialFont();
15424
15425         wxPyEndAllowThreads(__tstate);
15426         if (PyErr_Occurred()) SWIG_fail;
15427     }
15428     {
15429         wxFont * resultptr;
15430         resultptr = new wxFont((wxFont &)(result));
15431         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15432     }
15433     return resultobj;
15434     fail:
15435     return NULL;
15436 }
15437
15438
15439 static PyObject *_wrap_FontData_GetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15440     PyObject *resultobj;
15441     wxFontData *arg1 = (wxFontData *) 0 ;
15442     bool result;
15443     PyObject * obj0 = 0 ;
15444     char *kwnames[] = {
15445         (char *) "self", NULL
15446     };
15447
15448     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetShowHelp",kwnames,&obj0)) goto fail;
15449     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15450     if (SWIG_arg_fail(1)) SWIG_fail;
15451     {
15452         PyThreadState* __tstate = wxPyBeginAllowThreads();
15453         result = (bool)(arg1)->GetShowHelp();
15454
15455         wxPyEndAllowThreads(__tstate);
15456         if (PyErr_Occurred()) SWIG_fail;
15457     }
15458     {
15459         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15460     }
15461     return resultobj;
15462     fail:
15463     return NULL;
15464 }
15465
15466
15467 static PyObject *_wrap_FontData_SetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15468     PyObject *resultobj;
15469     wxFontData *arg1 = (wxFontData *) 0 ;
15470     bool arg2 ;
15471     PyObject * obj0 = 0 ;
15472     PyObject * obj1 = 0 ;
15473     char *kwnames[] = {
15474         (char *) "self",(char *) "allowSymbols", NULL
15475     };
15476
15477     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetAllowSymbols",kwnames,&obj0,&obj1)) goto fail;
15478     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15479     if (SWIG_arg_fail(1)) SWIG_fail;
15480     {
15481         arg2 = (bool)(SWIG_As_bool(obj1));
15482         if (SWIG_arg_fail(2)) SWIG_fail;
15483     }
15484     {
15485         PyThreadState* __tstate = wxPyBeginAllowThreads();
15486         (arg1)->SetAllowSymbols(arg2);
15487
15488         wxPyEndAllowThreads(__tstate);
15489         if (PyErr_Occurred()) SWIG_fail;
15490     }
15491     Py_INCREF(Py_None); resultobj = Py_None;
15492     return resultobj;
15493     fail:
15494     return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_FontData_SetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15499     PyObject *resultobj;
15500     wxFontData *arg1 = (wxFontData *) 0 ;
15501     wxFont *arg2 = 0 ;
15502     PyObject * obj0 = 0 ;
15503     PyObject * obj1 = 0 ;
15504     char *kwnames[] = {
15505         (char *) "self",(char *) "font", NULL
15506     };
15507
15508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetChosenFont",kwnames,&obj0,&obj1)) goto fail;
15509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15510     if (SWIG_arg_fail(1)) SWIG_fail;
15511     {
15512         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15513         if (SWIG_arg_fail(2)) SWIG_fail;
15514         if (arg2 == NULL) {
15515             SWIG_null_ref("wxFont");
15516         }
15517         if (SWIG_arg_fail(2)) SWIG_fail;
15518     }
15519     {
15520         PyThreadState* __tstate = wxPyBeginAllowThreads();
15521         (arg1)->SetChosenFont((wxFont const &)*arg2);
15522
15523         wxPyEndAllowThreads(__tstate);
15524         if (PyErr_Occurred()) SWIG_fail;
15525     }
15526     Py_INCREF(Py_None); resultobj = Py_None;
15527     return resultobj;
15528     fail:
15529     return NULL;
15530 }
15531
15532
15533 static PyObject *_wrap_FontData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15534     PyObject *resultobj;
15535     wxFontData *arg1 = (wxFontData *) 0 ;
15536     wxColour *arg2 = 0 ;
15537     wxColour temp2 ;
15538     PyObject * obj0 = 0 ;
15539     PyObject * obj1 = 0 ;
15540     char *kwnames[] = {
15541         (char *) "self",(char *) "colour", NULL
15542     };
15543
15544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetColour",kwnames,&obj0,&obj1)) goto fail;
15545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15546     if (SWIG_arg_fail(1)) SWIG_fail;
15547     {
15548         arg2 = &temp2;
15549         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15550     }
15551     {
15552         PyThreadState* __tstate = wxPyBeginAllowThreads();
15553         (arg1)->SetColour((wxColour const &)*arg2);
15554
15555         wxPyEndAllowThreads(__tstate);
15556         if (PyErr_Occurred()) SWIG_fail;
15557     }
15558     Py_INCREF(Py_None); resultobj = Py_None;
15559     return resultobj;
15560     fail:
15561     return NULL;
15562 }
15563
15564
15565 static PyObject *_wrap_FontData_SetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15566     PyObject *resultobj;
15567     wxFontData *arg1 = (wxFontData *) 0 ;
15568     wxFont *arg2 = 0 ;
15569     PyObject * obj0 = 0 ;
15570     PyObject * obj1 = 0 ;
15571     char *kwnames[] = {
15572         (char *) "self",(char *) "font", NULL
15573     };
15574
15575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetInitialFont",kwnames,&obj0,&obj1)) goto fail;
15576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15577     if (SWIG_arg_fail(1)) SWIG_fail;
15578     {
15579         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15580         if (SWIG_arg_fail(2)) SWIG_fail;
15581         if (arg2 == NULL) {
15582             SWIG_null_ref("wxFont");
15583         }
15584         if (SWIG_arg_fail(2)) SWIG_fail;
15585     }
15586     {
15587         PyThreadState* __tstate = wxPyBeginAllowThreads();
15588         (arg1)->SetInitialFont((wxFont const &)*arg2);
15589
15590         wxPyEndAllowThreads(__tstate);
15591         if (PyErr_Occurred()) SWIG_fail;
15592     }
15593     Py_INCREF(Py_None); resultobj = Py_None;
15594     return resultobj;
15595     fail:
15596     return NULL;
15597 }
15598
15599
15600 static PyObject *_wrap_FontData_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15601     PyObject *resultobj;
15602     wxFontData *arg1 = (wxFontData *) 0 ;
15603     int arg2 ;
15604     int arg3 ;
15605     PyObject * obj0 = 0 ;
15606     PyObject * obj1 = 0 ;
15607     PyObject * obj2 = 0 ;
15608     char *kwnames[] = {
15609         (char *) "self",(char *) "min",(char *) "max", NULL
15610     };
15611
15612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FontData_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15614     if (SWIG_arg_fail(1)) SWIG_fail;
15615     {
15616         arg2 = (int)(SWIG_As_int(obj1));
15617         if (SWIG_arg_fail(2)) SWIG_fail;
15618     }
15619     {
15620         arg3 = (int)(SWIG_As_int(obj2));
15621         if (SWIG_arg_fail(3)) SWIG_fail;
15622     }
15623     {
15624         PyThreadState* __tstate = wxPyBeginAllowThreads();
15625         (arg1)->SetRange(arg2,arg3);
15626
15627         wxPyEndAllowThreads(__tstate);
15628         if (PyErr_Occurred()) SWIG_fail;
15629     }
15630     Py_INCREF(Py_None); resultobj = Py_None;
15631     return resultobj;
15632     fail:
15633     return NULL;
15634 }
15635
15636
15637 static PyObject *_wrap_FontData_SetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15638     PyObject *resultobj;
15639     wxFontData *arg1 = (wxFontData *) 0 ;
15640     bool arg2 ;
15641     PyObject * obj0 = 0 ;
15642     PyObject * obj1 = 0 ;
15643     char *kwnames[] = {
15644         (char *) "self",(char *) "showHelp", NULL
15645     };
15646
15647     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetShowHelp",kwnames,&obj0,&obj1)) goto fail;
15648     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15649     if (SWIG_arg_fail(1)) SWIG_fail;
15650     {
15651         arg2 = (bool)(SWIG_As_bool(obj1));
15652         if (SWIG_arg_fail(2)) SWIG_fail;
15653     }
15654     {
15655         PyThreadState* __tstate = wxPyBeginAllowThreads();
15656         (arg1)->SetShowHelp(arg2);
15657
15658         wxPyEndAllowThreads(__tstate);
15659         if (PyErr_Occurred()) SWIG_fail;
15660     }
15661     Py_INCREF(Py_None); resultobj = Py_None;
15662     return resultobj;
15663     fail:
15664     return NULL;
15665 }
15666
15667
15668 static PyObject * FontData_swigregister(PyObject *, PyObject *args) {
15669     PyObject *obj;
15670     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15671     SWIG_TypeClientData(SWIGTYPE_p_wxFontData, obj);
15672     Py_INCREF(obj);
15673     return Py_BuildValue((char *)"");
15674 }
15675 static PyObject *_wrap_new_FontDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15676     PyObject *resultobj;
15677     wxWindow *arg1 = (wxWindow *) 0 ;
15678     wxFontData *arg2 = 0 ;
15679     wxFontDialog *result;
15680     PyObject * obj0 = 0 ;
15681     PyObject * obj1 = 0 ;
15682     char *kwnames[] = {
15683         (char *) "parent",(char *) "data", NULL
15684     };
15685
15686     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_FontDialog",kwnames,&obj0,&obj1)) goto fail;
15687     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15688     if (SWIG_arg_fail(1)) SWIG_fail;
15689     {
15690         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15691         if (SWIG_arg_fail(2)) SWIG_fail;
15692         if (arg2 == NULL) {
15693             SWIG_null_ref("wxFontData");
15694         }
15695         if (SWIG_arg_fail(2)) SWIG_fail;
15696     }
15697     {
15698         if (!wxPyCheckForApp()) SWIG_fail;
15699         PyThreadState* __tstate = wxPyBeginAllowThreads();
15700         result = (wxFontDialog *)new wxFontDialog(arg1,(wxFontData const &)*arg2);
15701
15702         wxPyEndAllowThreads(__tstate);
15703         if (PyErr_Occurred()) SWIG_fail;
15704     }
15705     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontDialog, 1);
15706     return resultobj;
15707     fail:
15708     return NULL;
15709 }
15710
15711
15712 static PyObject *_wrap_FontDialog_GetFontData(PyObject *, PyObject *args, PyObject *kwargs) {
15713     PyObject *resultobj;
15714     wxFontDialog *arg1 = (wxFontDialog *) 0 ;
15715     wxFontData *result;
15716     PyObject * obj0 = 0 ;
15717     char *kwnames[] = {
15718         (char *) "self", NULL
15719     };
15720
15721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontDialog_GetFontData",kwnames,&obj0)) goto fail;
15722     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontDialog, SWIG_POINTER_EXCEPTION | 0);
15723     if (SWIG_arg_fail(1)) SWIG_fail;
15724     {
15725         PyThreadState* __tstate = wxPyBeginAllowThreads();
15726         {
15727             wxFontData &_result_ref = (arg1)->GetFontData();
15728             result = (wxFontData *) &_result_ref;
15729         }
15730
15731         wxPyEndAllowThreads(__tstate);
15732         if (PyErr_Occurred()) SWIG_fail;
15733     }
15734     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 0);
15735     return resultobj;
15736     fail:
15737     return NULL;
15738 }
15739
15740
15741 static PyObject * FontDialog_swigregister(PyObject *, PyObject *args) {
15742     PyObject *obj;
15743     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15744     SWIG_TypeClientData(SWIGTYPE_p_wxFontDialog, obj);
15745     Py_INCREF(obj);
15746     return Py_BuildValue((char *)"");
15747 }
15748 static PyObject *_wrap_new_MessageDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15749     PyObject *resultobj;
15750     wxWindow *arg1 = (wxWindow *) 0 ;
15751     wxString *arg2 = 0 ;
15752     wxString const &arg3_defvalue = wxPyMessageBoxCaptionStr ;
15753     wxString *arg3 = (wxString *) &arg3_defvalue ;
15754     long arg4 = (long) wxOK|wxCANCEL|wxCENTRE ;
15755     wxPoint const &arg5_defvalue = wxDefaultPosition ;
15756     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
15757     wxMessageDialog *result;
15758     bool temp2 = false ;
15759     bool temp3 = false ;
15760     wxPoint temp5 ;
15761     PyObject * obj0 = 0 ;
15762     PyObject * obj1 = 0 ;
15763     PyObject * obj2 = 0 ;
15764     PyObject * obj3 = 0 ;
15765     PyObject * obj4 = 0 ;
15766     char *kwnames[] = {
15767         (char *) "parent",(char *) "message",(char *) "caption",(char *) "style",(char *) "pos", NULL
15768     };
15769
15770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_MessageDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15771     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15772     if (SWIG_arg_fail(1)) SWIG_fail;
15773     {
15774         arg2 = wxString_in_helper(obj1);
15775         if (arg2 == NULL) SWIG_fail;
15776         temp2 = true;
15777     }
15778     if (obj2) {
15779         {
15780             arg3 = wxString_in_helper(obj2);
15781             if (arg3 == NULL) SWIG_fail;
15782             temp3 = true;
15783         }
15784     }
15785     if (obj3) {
15786         {
15787             arg4 = (long)(SWIG_As_long(obj3));
15788             if (SWIG_arg_fail(4)) SWIG_fail;
15789         }
15790     }
15791     if (obj4) {
15792         {
15793             arg5 = &temp5;
15794             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
15795         }
15796     }
15797     {
15798         if (!wxPyCheckForApp()) SWIG_fail;
15799         PyThreadState* __tstate = wxPyBeginAllowThreads();
15800         result = (wxMessageDialog *)new wxMessageDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5);
15801
15802         wxPyEndAllowThreads(__tstate);
15803         if (PyErr_Occurred()) SWIG_fail;
15804     }
15805     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMessageDialog, 1);
15806     {
15807         if (temp2)
15808         delete arg2;
15809     }
15810     {
15811         if (temp3)
15812         delete arg3;
15813     }
15814     return resultobj;
15815     fail:
15816     {
15817         if (temp2)
15818         delete arg2;
15819     }
15820     {
15821         if (temp3)
15822         delete arg3;
15823     }
15824     return NULL;
15825 }
15826
15827
15828 static PyObject * MessageDialog_swigregister(PyObject *, PyObject *args) {
15829     PyObject *obj;
15830     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15831     SWIG_TypeClientData(SWIGTYPE_p_wxMessageDialog, obj);
15832     Py_INCREF(obj);
15833     return Py_BuildValue((char *)"");
15834 }
15835 static PyObject *_wrap_new_ProgressDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15836     PyObject *resultobj;
15837     wxString *arg1 = 0 ;
15838     wxString *arg2 = 0 ;
15839     int arg3 = (int) 100 ;
15840     wxWindow *arg4 = (wxWindow *) NULL ;
15841     int arg5 = (int) wxPD_AUTO_HIDE|wxPD_APP_MODAL ;
15842     wxProgressDialog *result;
15843     bool temp1 = false ;
15844     bool temp2 = false ;
15845     PyObject * obj0 = 0 ;
15846     PyObject * obj1 = 0 ;
15847     PyObject * obj2 = 0 ;
15848     PyObject * obj3 = 0 ;
15849     PyObject * obj4 = 0 ;
15850     char *kwnames[] = {
15851         (char *) "title",(char *) "message",(char *) "maximum",(char *) "parent",(char *) "style", NULL
15852     };
15853
15854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_ProgressDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15855     {
15856         arg1 = wxString_in_helper(obj0);
15857         if (arg1 == NULL) SWIG_fail;
15858         temp1 = true;
15859     }
15860     {
15861         arg2 = wxString_in_helper(obj1);
15862         if (arg2 == NULL) SWIG_fail;
15863         temp2 = true;
15864     }
15865     if (obj2) {
15866         {
15867             arg3 = (int)(SWIG_As_int(obj2));
15868             if (SWIG_arg_fail(3)) SWIG_fail;
15869         }
15870     }
15871     if (obj3) {
15872         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15873         if (SWIG_arg_fail(4)) SWIG_fail;
15874     }
15875     if (obj4) {
15876         {
15877             arg5 = (int)(SWIG_As_int(obj4));
15878             if (SWIG_arg_fail(5)) SWIG_fail;
15879         }
15880     }
15881     {
15882         if (!wxPyCheckForApp()) SWIG_fail;
15883         PyThreadState* __tstate = wxPyBeginAllowThreads();
15884         result = (wxProgressDialog *)new wxProgressDialog((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5);
15885
15886         wxPyEndAllowThreads(__tstate);
15887         if (PyErr_Occurred()) SWIG_fail;
15888     }
15889     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProgressDialog, 1);
15890     {
15891         if (temp1)
15892         delete arg1;
15893     }
15894     {
15895         if (temp2)
15896         delete arg2;
15897     }
15898     return resultobj;
15899     fail:
15900     {
15901         if (temp1)
15902         delete arg1;
15903     }
15904     {
15905         if (temp2)
15906         delete arg2;
15907     }
15908     return NULL;
15909 }
15910
15911
15912 static PyObject *_wrap_ProgressDialog_Update(PyObject *, PyObject *args, PyObject *kwargs) {
15913     PyObject *resultobj;
15914     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15915     int arg2 ;
15916     wxString const &arg3_defvalue = wxPyEmptyString ;
15917     wxString *arg3 = (wxString *) &arg3_defvalue ;
15918     bool result;
15919     bool temp3 = false ;
15920     PyObject * obj0 = 0 ;
15921     PyObject * obj1 = 0 ;
15922     PyObject * obj2 = 0 ;
15923     char *kwnames[] = {
15924         (char *) "self",(char *) "value",(char *) "newmsg", NULL
15925     };
15926
15927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ProgressDialog_Update",kwnames,&obj0,&obj1,&obj2)) goto fail;
15928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15929     if (SWIG_arg_fail(1)) SWIG_fail;
15930     {
15931         arg2 = (int)(SWIG_As_int(obj1));
15932         if (SWIG_arg_fail(2)) SWIG_fail;
15933     }
15934     if (obj2) {
15935         {
15936             arg3 = wxString_in_helper(obj2);
15937             if (arg3 == NULL) SWIG_fail;
15938             temp3 = true;
15939         }
15940     }
15941     {
15942         PyThreadState* __tstate = wxPyBeginAllowThreads();
15943         result = (bool)(arg1)->Update(arg2,(wxString const &)*arg3);
15944
15945         wxPyEndAllowThreads(__tstate);
15946         if (PyErr_Occurred()) SWIG_fail;
15947     }
15948     {
15949         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15950     }
15951     {
15952         if (temp3)
15953         delete arg3;
15954     }
15955     return resultobj;
15956     fail:
15957     {
15958         if (temp3)
15959         delete arg3;
15960     }
15961     return NULL;
15962 }
15963
15964
15965 static PyObject *_wrap_ProgressDialog_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
15966     PyObject *resultobj;
15967     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15968     PyObject * obj0 = 0 ;
15969     char *kwnames[] = {
15970         (char *) "self", NULL
15971     };
15972
15973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProgressDialog_Resume",kwnames,&obj0)) goto fail;
15974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15975     if (SWIG_arg_fail(1)) SWIG_fail;
15976     {
15977         PyThreadState* __tstate = wxPyBeginAllowThreads();
15978         (arg1)->Resume();
15979
15980         wxPyEndAllowThreads(__tstate);
15981         if (PyErr_Occurred()) SWIG_fail;
15982     }
15983     Py_INCREF(Py_None); resultobj = Py_None;
15984     return resultobj;
15985     fail:
15986     return NULL;
15987 }
15988
15989
15990 static PyObject * ProgressDialog_swigregister(PyObject *, PyObject *args) {
15991     PyObject *obj;
15992     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15993     SWIG_TypeClientData(SWIGTYPE_p_wxProgressDialog, obj);
15994     Py_INCREF(obj);
15995     return Py_BuildValue((char *)"");
15996 }
15997 static PyObject *_wrap_new_FindDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15998     PyObject *resultobj;
15999     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16000     int arg2 = (int) 0 ;
16001     wxFindDialogEvent *result;
16002     PyObject * obj0 = 0 ;
16003     PyObject * obj1 = 0 ;
16004     char *kwnames[] = {
16005         (char *) "commandType",(char *) "id", NULL
16006     };
16007
16008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FindDialogEvent",kwnames,&obj0,&obj1)) goto fail;
16009     if (obj0) {
16010         {
16011             arg1 = (wxEventType)(SWIG_As_int(obj0));
16012             if (SWIG_arg_fail(1)) SWIG_fail;
16013         }
16014     }
16015     if (obj1) {
16016         {
16017             arg2 = (int)(SWIG_As_int(obj1));
16018             if (SWIG_arg_fail(2)) SWIG_fail;
16019         }
16020     }
16021     {
16022         PyThreadState* __tstate = wxPyBeginAllowThreads();
16023         result = (wxFindDialogEvent *)new wxFindDialogEvent(arg1,arg2);
16024
16025         wxPyEndAllowThreads(__tstate);
16026         if (PyErr_Occurred()) SWIG_fail;
16027     }
16028     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindDialogEvent, 1);
16029     return resultobj;
16030     fail:
16031     return NULL;
16032 }
16033
16034
16035 static PyObject *_wrap_FindDialogEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16036     PyObject *resultobj;
16037     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16038     int result;
16039     PyObject * obj0 = 0 ;
16040     char *kwnames[] = {
16041         (char *) "self", NULL
16042     };
16043
16044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFlags",kwnames,&obj0)) goto fail;
16045     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16046     if (SWIG_arg_fail(1)) SWIG_fail;
16047     {
16048         PyThreadState* __tstate = wxPyBeginAllowThreads();
16049         result = (int)(arg1)->GetFlags();
16050
16051         wxPyEndAllowThreads(__tstate);
16052         if (PyErr_Occurred()) SWIG_fail;
16053     }
16054     {
16055         resultobj = SWIG_From_int((int)(result));
16056     }
16057     return resultobj;
16058     fail:
16059     return NULL;
16060 }
16061
16062
16063 static PyObject *_wrap_FindDialogEvent_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16064     PyObject *resultobj;
16065     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16066     wxString *result;
16067     PyObject * obj0 = 0 ;
16068     char *kwnames[] = {
16069         (char *) "self", NULL
16070     };
16071
16072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFindString",kwnames,&obj0)) goto fail;
16073     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16074     if (SWIG_arg_fail(1)) SWIG_fail;
16075     {
16076         PyThreadState* __tstate = wxPyBeginAllowThreads();
16077         {
16078             wxString const &_result_ref = (arg1)->GetFindString();
16079             result = (wxString *) &_result_ref;
16080         }
16081
16082         wxPyEndAllowThreads(__tstate);
16083         if (PyErr_Occurred()) SWIG_fail;
16084     }
16085     {
16086 #if wxUSE_UNICODE
16087         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16088 #else
16089         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16090 #endif
16091     }
16092     return resultobj;
16093     fail:
16094     return NULL;
16095 }
16096
16097
16098 static PyObject *_wrap_FindDialogEvent_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16099     PyObject *resultobj;
16100     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16101     wxString *result;
16102     PyObject * obj0 = 0 ;
16103     char *kwnames[] = {
16104         (char *) "self", NULL
16105     };
16106
16107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetReplaceString",kwnames,&obj0)) goto fail;
16108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16109     if (SWIG_arg_fail(1)) SWIG_fail;
16110     {
16111         PyThreadState* __tstate = wxPyBeginAllowThreads();
16112         {
16113             wxString const &_result_ref = (arg1)->GetReplaceString();
16114             result = (wxString *) &_result_ref;
16115         }
16116
16117         wxPyEndAllowThreads(__tstate);
16118         if (PyErr_Occurred()) SWIG_fail;
16119     }
16120     {
16121 #if wxUSE_UNICODE
16122         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16123 #else
16124         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16125 #endif
16126     }
16127     return resultobj;
16128     fail:
16129     return NULL;
16130 }
16131
16132
16133 static PyObject *_wrap_FindDialogEvent_GetDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16134     PyObject *resultobj;
16135     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16136     wxFindReplaceDialog *result;
16137     PyObject * obj0 = 0 ;
16138     char *kwnames[] = {
16139         (char *) "self", NULL
16140     };
16141
16142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetDialog",kwnames,&obj0)) goto fail;
16143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16144     if (SWIG_arg_fail(1)) SWIG_fail;
16145     {
16146         PyThreadState* __tstate = wxPyBeginAllowThreads();
16147         result = (wxFindReplaceDialog *)(arg1)->GetDialog();
16148
16149         wxPyEndAllowThreads(__tstate);
16150         if (PyErr_Occurred()) SWIG_fail;
16151     }
16152     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 0);
16153     return resultobj;
16154     fail:
16155     return NULL;
16156 }
16157
16158
16159 static PyObject *_wrap_FindDialogEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16160     PyObject *resultobj;
16161     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16162     int arg2 ;
16163     PyObject * obj0 = 0 ;
16164     PyObject * obj1 = 0 ;
16165     char *kwnames[] = {
16166         (char *) "self",(char *) "flags", NULL
16167     };
16168
16169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFlags",kwnames,&obj0,&obj1)) 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         arg2 = (int)(SWIG_As_int(obj1));
16174         if (SWIG_arg_fail(2)) SWIG_fail;
16175     }
16176     {
16177         PyThreadState* __tstate = wxPyBeginAllowThreads();
16178         (arg1)->SetFlags(arg2);
16179
16180         wxPyEndAllowThreads(__tstate);
16181         if (PyErr_Occurred()) SWIG_fail;
16182     }
16183     Py_INCREF(Py_None); resultobj = Py_None;
16184     return resultobj;
16185     fail:
16186     return NULL;
16187 }
16188
16189
16190 static PyObject *_wrap_FindDialogEvent_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16191     PyObject *resultobj;
16192     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16193     wxString *arg2 = 0 ;
16194     bool temp2 = false ;
16195     PyObject * obj0 = 0 ;
16196     PyObject * obj1 = 0 ;
16197     char *kwnames[] = {
16198         (char *) "self",(char *) "str", NULL
16199     };
16200
16201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16202     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16203     if (SWIG_arg_fail(1)) SWIG_fail;
16204     {
16205         arg2 = wxString_in_helper(obj1);
16206         if (arg2 == NULL) SWIG_fail;
16207         temp2 = true;
16208     }
16209     {
16210         PyThreadState* __tstate = wxPyBeginAllowThreads();
16211         (arg1)->SetFindString((wxString const &)*arg2);
16212
16213         wxPyEndAllowThreads(__tstate);
16214         if (PyErr_Occurred()) SWIG_fail;
16215     }
16216     Py_INCREF(Py_None); resultobj = Py_None;
16217     {
16218         if (temp2)
16219         delete arg2;
16220     }
16221     return resultobj;
16222     fail:
16223     {
16224         if (temp2)
16225         delete arg2;
16226     }
16227     return NULL;
16228 }
16229
16230
16231 static PyObject *_wrap_FindDialogEvent_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16232     PyObject *resultobj;
16233     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16234     wxString *arg2 = 0 ;
16235     bool temp2 = false ;
16236     PyObject * obj0 = 0 ;
16237     PyObject * obj1 = 0 ;
16238     char *kwnames[] = {
16239         (char *) "self",(char *) "str", NULL
16240     };
16241
16242     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16243     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16244     if (SWIG_arg_fail(1)) SWIG_fail;
16245     {
16246         arg2 = wxString_in_helper(obj1);
16247         if (arg2 == NULL) SWIG_fail;
16248         temp2 = true;
16249     }
16250     {
16251         PyThreadState* __tstate = wxPyBeginAllowThreads();
16252         (arg1)->SetReplaceString((wxString const &)*arg2);
16253
16254         wxPyEndAllowThreads(__tstate);
16255         if (PyErr_Occurred()) SWIG_fail;
16256     }
16257     Py_INCREF(Py_None); resultobj = Py_None;
16258     {
16259         if (temp2)
16260         delete arg2;
16261     }
16262     return resultobj;
16263     fail:
16264     {
16265         if (temp2)
16266         delete arg2;
16267     }
16268     return NULL;
16269 }
16270
16271
16272 static PyObject * FindDialogEvent_swigregister(PyObject *, PyObject *args) {
16273     PyObject *obj;
16274     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16275     SWIG_TypeClientData(SWIGTYPE_p_wxFindDialogEvent, obj);
16276     Py_INCREF(obj);
16277     return Py_BuildValue((char *)"");
16278 }
16279 static PyObject *_wrap_new_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16280     PyObject *resultobj;
16281     int arg1 = (int) 0 ;
16282     wxFindReplaceData *result;
16283     PyObject * obj0 = 0 ;
16284     char *kwnames[] = {
16285         (char *) "flags", NULL
16286     };
16287
16288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_FindReplaceData",kwnames,&obj0)) goto fail;
16289     if (obj0) {
16290         {
16291             arg1 = (int)(SWIG_As_int(obj0));
16292             if (SWIG_arg_fail(1)) SWIG_fail;
16293         }
16294     }
16295     {
16296         PyThreadState* __tstate = wxPyBeginAllowThreads();
16297         result = (wxFindReplaceData *)new wxFindReplaceData(arg1);
16298
16299         wxPyEndAllowThreads(__tstate);
16300         if (PyErr_Occurred()) SWIG_fail;
16301     }
16302     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 1);
16303     return resultobj;
16304     fail:
16305     return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_delete_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16310     PyObject *resultobj;
16311     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16312     PyObject * obj0 = 0 ;
16313     char *kwnames[] = {
16314         (char *) "self", NULL
16315     };
16316
16317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FindReplaceData",kwnames,&obj0)) goto fail;
16318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16319     if (SWIG_arg_fail(1)) SWIG_fail;
16320     {
16321         PyThreadState* __tstate = wxPyBeginAllowThreads();
16322         delete arg1;
16323
16324         wxPyEndAllowThreads(__tstate);
16325         if (PyErr_Occurred()) SWIG_fail;
16326     }
16327     Py_INCREF(Py_None); resultobj = Py_None;
16328     return resultobj;
16329     fail:
16330     return NULL;
16331 }
16332
16333
16334 static PyObject *_wrap_FindReplaceData_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16335     PyObject *resultobj;
16336     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16337     wxString *result;
16338     PyObject * obj0 = 0 ;
16339     char *kwnames[] = {
16340         (char *) "self", NULL
16341     };
16342
16343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFindString",kwnames,&obj0)) goto fail;
16344     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16345     if (SWIG_arg_fail(1)) SWIG_fail;
16346     {
16347         PyThreadState* __tstate = wxPyBeginAllowThreads();
16348         {
16349             wxString const &_result_ref = (arg1)->GetFindString();
16350             result = (wxString *) &_result_ref;
16351         }
16352
16353         wxPyEndAllowThreads(__tstate);
16354         if (PyErr_Occurred()) SWIG_fail;
16355     }
16356     {
16357 #if wxUSE_UNICODE
16358         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16359 #else
16360         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16361 #endif
16362     }
16363     return resultobj;
16364     fail:
16365     return NULL;
16366 }
16367
16368
16369 static PyObject *_wrap_FindReplaceData_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16370     PyObject *resultobj;
16371     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16372     wxString *result;
16373     PyObject * obj0 = 0 ;
16374     char *kwnames[] = {
16375         (char *) "self", NULL
16376     };
16377
16378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetReplaceString",kwnames,&obj0)) goto fail;
16379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16380     if (SWIG_arg_fail(1)) SWIG_fail;
16381     {
16382         PyThreadState* __tstate = wxPyBeginAllowThreads();
16383         {
16384             wxString const &_result_ref = (arg1)->GetReplaceString();
16385             result = (wxString *) &_result_ref;
16386         }
16387
16388         wxPyEndAllowThreads(__tstate);
16389         if (PyErr_Occurred()) SWIG_fail;
16390     }
16391     {
16392 #if wxUSE_UNICODE
16393         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16394 #else
16395         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16396 #endif
16397     }
16398     return resultobj;
16399     fail:
16400     return NULL;
16401 }
16402
16403
16404 static PyObject *_wrap_FindReplaceData_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16405     PyObject *resultobj;
16406     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16407     int result;
16408     PyObject * obj0 = 0 ;
16409     char *kwnames[] = {
16410         (char *) "self", NULL
16411     };
16412
16413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFlags",kwnames,&obj0)) goto fail;
16414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16415     if (SWIG_arg_fail(1)) SWIG_fail;
16416     {
16417         PyThreadState* __tstate = wxPyBeginAllowThreads();
16418         result = (int)(arg1)->GetFlags();
16419
16420         wxPyEndAllowThreads(__tstate);
16421         if (PyErr_Occurred()) SWIG_fail;
16422     }
16423     {
16424         resultobj = SWIG_From_int((int)(result));
16425     }
16426     return resultobj;
16427     fail:
16428     return NULL;
16429 }
16430
16431
16432 static PyObject *_wrap_FindReplaceData_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16433     PyObject *resultobj;
16434     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16435     int arg2 ;
16436     PyObject * obj0 = 0 ;
16437     PyObject * obj1 = 0 ;
16438     char *kwnames[] = {
16439         (char *) "self",(char *) "flags", NULL
16440     };
16441
16442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16444     if (SWIG_arg_fail(1)) SWIG_fail;
16445     {
16446         arg2 = (int)(SWIG_As_int(obj1));
16447         if (SWIG_arg_fail(2)) SWIG_fail;
16448     }
16449     {
16450         PyThreadState* __tstate = wxPyBeginAllowThreads();
16451         (arg1)->SetFlags(arg2);
16452
16453         wxPyEndAllowThreads(__tstate);
16454         if (PyErr_Occurred()) SWIG_fail;
16455     }
16456     Py_INCREF(Py_None); resultobj = Py_None;
16457     return resultobj;
16458     fail:
16459     return NULL;
16460 }
16461
16462
16463 static PyObject *_wrap_FindReplaceData_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16464     PyObject *resultobj;
16465     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16466     wxString *arg2 = 0 ;
16467     bool temp2 = false ;
16468     PyObject * obj0 = 0 ;
16469     PyObject * obj1 = 0 ;
16470     char *kwnames[] = {
16471         (char *) "self",(char *) "str", NULL
16472     };
16473
16474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16476     if (SWIG_arg_fail(1)) SWIG_fail;
16477     {
16478         arg2 = wxString_in_helper(obj1);
16479         if (arg2 == NULL) SWIG_fail;
16480         temp2 = true;
16481     }
16482     {
16483         PyThreadState* __tstate = wxPyBeginAllowThreads();
16484         (arg1)->SetFindString((wxString const &)*arg2);
16485
16486         wxPyEndAllowThreads(__tstate);
16487         if (PyErr_Occurred()) SWIG_fail;
16488     }
16489     Py_INCREF(Py_None); resultobj = Py_None;
16490     {
16491         if (temp2)
16492         delete arg2;
16493     }
16494     return resultobj;
16495     fail:
16496     {
16497         if (temp2)
16498         delete arg2;
16499     }
16500     return NULL;
16501 }
16502
16503
16504 static PyObject *_wrap_FindReplaceData_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16505     PyObject *resultobj;
16506     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16507     wxString *arg2 = 0 ;
16508     bool temp2 = false ;
16509     PyObject * obj0 = 0 ;
16510     PyObject * obj1 = 0 ;
16511     char *kwnames[] = {
16512         (char *) "self",(char *) "str", NULL
16513     };
16514
16515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16517     if (SWIG_arg_fail(1)) SWIG_fail;
16518     {
16519         arg2 = wxString_in_helper(obj1);
16520         if (arg2 == NULL) SWIG_fail;
16521         temp2 = true;
16522     }
16523     {
16524         PyThreadState* __tstate = wxPyBeginAllowThreads();
16525         (arg1)->SetReplaceString((wxString const &)*arg2);
16526
16527         wxPyEndAllowThreads(__tstate);
16528         if (PyErr_Occurred()) SWIG_fail;
16529     }
16530     Py_INCREF(Py_None); resultobj = Py_None;
16531     {
16532         if (temp2)
16533         delete arg2;
16534     }
16535     return resultobj;
16536     fail:
16537     {
16538         if (temp2)
16539         delete arg2;
16540     }
16541     return NULL;
16542 }
16543
16544
16545 static PyObject * FindReplaceData_swigregister(PyObject *, PyObject *args) {
16546     PyObject *obj;
16547     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16548     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceData, obj);
16549     Py_INCREF(obj);
16550     return Py_BuildValue((char *)"");
16551 }
16552 static PyObject *_wrap_new_FindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16553     PyObject *resultobj;
16554     wxWindow *arg1 = (wxWindow *) 0 ;
16555     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16556     wxString *arg3 = 0 ;
16557     int arg4 = (int) 0 ;
16558     wxFindReplaceDialog *result;
16559     bool temp3 = false ;
16560     PyObject * obj0 = 0 ;
16561     PyObject * obj1 = 0 ;
16562     PyObject * obj2 = 0 ;
16563     PyObject * obj3 = 0 ;
16564     char *kwnames[] = {
16565         (char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16566     };
16567
16568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_FindReplaceDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16570     if (SWIG_arg_fail(1)) SWIG_fail;
16571     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16572     if (SWIG_arg_fail(2)) SWIG_fail;
16573     {
16574         arg3 = wxString_in_helper(obj2);
16575         if (arg3 == NULL) SWIG_fail;
16576         temp3 = true;
16577     }
16578     if (obj3) {
16579         {
16580             arg4 = (int)(SWIG_As_int(obj3));
16581             if (SWIG_arg_fail(4)) SWIG_fail;
16582         }
16583     }
16584     {
16585         if (!wxPyCheckForApp()) SWIG_fail;
16586         PyThreadState* __tstate = wxPyBeginAllowThreads();
16587         result = (wxFindReplaceDialog *)new wxFindReplaceDialog(arg1,arg2,(wxString const &)*arg3,arg4);
16588
16589         wxPyEndAllowThreads(__tstate);
16590         if (PyErr_Occurred()) SWIG_fail;
16591     }
16592     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16593     {
16594         if (temp3)
16595         delete arg3;
16596     }
16597     return resultobj;
16598     fail:
16599     {
16600         if (temp3)
16601         delete arg3;
16602     }
16603     return NULL;
16604 }
16605
16606
16607 static PyObject *_wrap_new_PreFindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16608     PyObject *resultobj;
16609     wxFindReplaceDialog *result;
16610     char *kwnames[] = {
16611         NULL
16612     };
16613
16614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFindReplaceDialog",kwnames)) goto fail;
16615     {
16616         if (!wxPyCheckForApp()) SWIG_fail;
16617         PyThreadState* __tstate = wxPyBeginAllowThreads();
16618         result = (wxFindReplaceDialog *)new wxFindReplaceDialog();
16619
16620         wxPyEndAllowThreads(__tstate);
16621         if (PyErr_Occurred()) SWIG_fail;
16622     }
16623     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16624     return resultobj;
16625     fail:
16626     return NULL;
16627 }
16628
16629
16630 static PyObject *_wrap_FindReplaceDialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16631     PyObject *resultobj;
16632     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16633     wxWindow *arg2 = (wxWindow *) 0 ;
16634     wxFindReplaceData *arg3 = (wxFindReplaceData *) 0 ;
16635     wxString *arg4 = 0 ;
16636     int arg5 = (int) 0 ;
16637     bool result;
16638     bool temp4 = false ;
16639     PyObject * obj0 = 0 ;
16640     PyObject * obj1 = 0 ;
16641     PyObject * obj2 = 0 ;
16642     PyObject * obj3 = 0 ;
16643     PyObject * obj4 = 0 ;
16644     char *kwnames[] = {
16645         (char *) "self",(char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16646     };
16647
16648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:FindReplaceDialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16649     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16650     if (SWIG_arg_fail(1)) SWIG_fail;
16651     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16652     if (SWIG_arg_fail(2)) SWIG_fail;
16653     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16654     if (SWIG_arg_fail(3)) SWIG_fail;
16655     {
16656         arg4 = wxString_in_helper(obj3);
16657         if (arg4 == NULL) SWIG_fail;
16658         temp4 = true;
16659     }
16660     if (obj4) {
16661         {
16662             arg5 = (int)(SWIG_As_int(obj4));
16663             if (SWIG_arg_fail(5)) SWIG_fail;
16664         }
16665     }
16666     {
16667         PyThreadState* __tstate = wxPyBeginAllowThreads();
16668         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,arg5);
16669
16670         wxPyEndAllowThreads(__tstate);
16671         if (PyErr_Occurred()) SWIG_fail;
16672     }
16673     {
16674         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16675     }
16676     {
16677         if (temp4)
16678         delete arg4;
16679     }
16680     return resultobj;
16681     fail:
16682     {
16683         if (temp4)
16684         delete arg4;
16685     }
16686     return NULL;
16687 }
16688
16689
16690 static PyObject *_wrap_FindReplaceDialog_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
16691     PyObject *resultobj;
16692     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16693     wxFindReplaceData *result;
16694     PyObject * obj0 = 0 ;
16695     char *kwnames[] = {
16696         (char *) "self", NULL
16697     };
16698
16699     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceDialog_GetData",kwnames,&obj0)) goto fail;
16700     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16701     if (SWIG_arg_fail(1)) SWIG_fail;
16702     {
16703         PyThreadState* __tstate = wxPyBeginAllowThreads();
16704         result = (wxFindReplaceData *)(arg1)->GetData();
16705
16706         wxPyEndAllowThreads(__tstate);
16707         if (PyErr_Occurred()) SWIG_fail;
16708     }
16709     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 0);
16710     return resultobj;
16711     fail:
16712     return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_FindReplaceDialog_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
16717     PyObject *resultobj;
16718     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16719     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16720     PyObject * obj0 = 0 ;
16721     PyObject * obj1 = 0 ;
16722     char *kwnames[] = {
16723         (char *) "self",(char *) "data", NULL
16724     };
16725
16726     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceDialog_SetData",kwnames,&obj0,&obj1)) goto fail;
16727     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16728     if (SWIG_arg_fail(1)) SWIG_fail;
16729     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16730     if (SWIG_arg_fail(2)) SWIG_fail;
16731     {
16732         PyThreadState* __tstate = wxPyBeginAllowThreads();
16733         (arg1)->SetData(arg2);
16734
16735         wxPyEndAllowThreads(__tstate);
16736         if (PyErr_Occurred()) SWIG_fail;
16737     }
16738     Py_INCREF(Py_None); resultobj = Py_None;
16739     return resultobj;
16740     fail:
16741     return NULL;
16742 }
16743
16744
16745 static PyObject * FindReplaceDialog_swigregister(PyObject *, PyObject *args) {
16746     PyObject *obj;
16747     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16748     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceDialog, obj);
16749     Py_INCREF(obj);
16750     return Py_BuildValue((char *)"");
16751 }
16752 static PyObject *_wrap_new_MDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16753     PyObject *resultobj;
16754     wxWindow *arg1 = (wxWindow *) 0 ;
16755     int arg2 = (int) (int)-1 ;
16756     wxString const &arg3_defvalue = wxPyEmptyString ;
16757     wxString *arg3 = (wxString *) &arg3_defvalue ;
16758     wxPoint const &arg4_defvalue = wxDefaultPosition ;
16759     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
16760     wxSize const &arg5_defvalue = wxDefaultSize ;
16761     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
16762     long arg6 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16763     wxString const &arg7_defvalue = wxPyFrameNameStr ;
16764     wxString *arg7 = (wxString *) &arg7_defvalue ;
16765     wxMDIParentFrame *result;
16766     bool temp3 = false ;
16767     wxPoint temp4 ;
16768     wxSize temp5 ;
16769     bool temp7 = false ;
16770     PyObject * obj0 = 0 ;
16771     PyObject * obj1 = 0 ;
16772     PyObject * obj2 = 0 ;
16773     PyObject * obj3 = 0 ;
16774     PyObject * obj4 = 0 ;
16775     PyObject * obj5 = 0 ;
16776     PyObject * obj6 = 0 ;
16777     char *kwnames[] = {
16778         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16779     };
16780
16781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIParentFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
16782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16783     if (SWIG_arg_fail(1)) SWIG_fail;
16784     if (obj1) {
16785         {
16786             arg2 = (int const)(SWIG_As_int(obj1));
16787             if (SWIG_arg_fail(2)) SWIG_fail;
16788         }
16789     }
16790     if (obj2) {
16791         {
16792             arg3 = wxString_in_helper(obj2);
16793             if (arg3 == NULL) SWIG_fail;
16794             temp3 = true;
16795         }
16796     }
16797     if (obj3) {
16798         {
16799             arg4 = &temp4;
16800             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
16801         }
16802     }
16803     if (obj4) {
16804         {
16805             arg5 = &temp5;
16806             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
16807         }
16808     }
16809     if (obj5) {
16810         {
16811             arg6 = (long)(SWIG_As_long(obj5));
16812             if (SWIG_arg_fail(6)) SWIG_fail;
16813         }
16814     }
16815     if (obj6) {
16816         {
16817             arg7 = wxString_in_helper(obj6);
16818             if (arg7 == NULL) SWIG_fail;
16819             temp7 = true;
16820         }
16821     }
16822     {
16823         if (!wxPyCheckForApp()) SWIG_fail;
16824         PyThreadState* __tstate = wxPyBeginAllowThreads();
16825         result = (wxMDIParentFrame *)new wxMDIParentFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
16826
16827         wxPyEndAllowThreads(__tstate);
16828         if (PyErr_Occurred()) SWIG_fail;
16829     }
16830     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16831     {
16832         if (temp3)
16833         delete arg3;
16834     }
16835     {
16836         if (temp7)
16837         delete arg7;
16838     }
16839     return resultobj;
16840     fail:
16841     {
16842         if (temp3)
16843         delete arg3;
16844     }
16845     {
16846         if (temp7)
16847         delete arg7;
16848     }
16849     return NULL;
16850 }
16851
16852
16853 static PyObject *_wrap_new_PreMDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16854     PyObject *resultobj;
16855     wxMDIParentFrame *result;
16856     char *kwnames[] = {
16857         NULL
16858     };
16859
16860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIParentFrame",kwnames)) goto fail;
16861     {
16862         if (!wxPyCheckForApp()) SWIG_fail;
16863         PyThreadState* __tstate = wxPyBeginAllowThreads();
16864         result = (wxMDIParentFrame *)new wxMDIParentFrame();
16865
16866         wxPyEndAllowThreads(__tstate);
16867         if (PyErr_Occurred()) SWIG_fail;
16868     }
16869     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16870     return resultobj;
16871     fail:
16872     return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_MDIParentFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16877     PyObject *resultobj;
16878     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16879     wxWindow *arg2 = (wxWindow *) 0 ;
16880     int arg3 = (int) (int)-1 ;
16881     wxString const &arg4_defvalue = wxPyEmptyString ;
16882     wxString *arg4 = (wxString *) &arg4_defvalue ;
16883     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16884     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16885     wxSize const &arg6_defvalue = wxDefaultSize ;
16886     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16887     long arg7 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16888     wxString const &arg8_defvalue = wxPyFrameNameStr ;
16889     wxString *arg8 = (wxString *) &arg8_defvalue ;
16890     bool result;
16891     bool temp4 = false ;
16892     wxPoint temp5 ;
16893     wxSize temp6 ;
16894     bool temp8 = false ;
16895     PyObject * obj0 = 0 ;
16896     PyObject * obj1 = 0 ;
16897     PyObject * obj2 = 0 ;
16898     PyObject * obj3 = 0 ;
16899     PyObject * obj4 = 0 ;
16900     PyObject * obj5 = 0 ;
16901     PyObject * obj6 = 0 ;
16902     PyObject * obj7 = 0 ;
16903     char *kwnames[] = {
16904         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16905     };
16906
16907     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIParentFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
16908     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16909     if (SWIG_arg_fail(1)) SWIG_fail;
16910     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16911     if (SWIG_arg_fail(2)) SWIG_fail;
16912     if (obj2) {
16913         {
16914             arg3 = (int const)(SWIG_As_int(obj2));
16915             if (SWIG_arg_fail(3)) SWIG_fail;
16916         }
16917     }
16918     if (obj3) {
16919         {
16920             arg4 = wxString_in_helper(obj3);
16921             if (arg4 == NULL) SWIG_fail;
16922             temp4 = true;
16923         }
16924     }
16925     if (obj4) {
16926         {
16927             arg5 = &temp5;
16928             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16929         }
16930     }
16931     if (obj5) {
16932         {
16933             arg6 = &temp6;
16934             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16935         }
16936     }
16937     if (obj6) {
16938         {
16939             arg7 = (long)(SWIG_As_long(obj6));
16940             if (SWIG_arg_fail(7)) SWIG_fail;
16941         }
16942     }
16943     if (obj7) {
16944         {
16945             arg8 = wxString_in_helper(obj7);
16946             if (arg8 == NULL) SWIG_fail;
16947             temp8 = true;
16948         }
16949     }
16950     {
16951         PyThreadState* __tstate = wxPyBeginAllowThreads();
16952         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
16953
16954         wxPyEndAllowThreads(__tstate);
16955         if (PyErr_Occurred()) SWIG_fail;
16956     }
16957     {
16958         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16959     }
16960     {
16961         if (temp4)
16962         delete arg4;
16963     }
16964     {
16965         if (temp8)
16966         delete arg8;
16967     }
16968     return resultobj;
16969     fail:
16970     {
16971         if (temp4)
16972         delete arg4;
16973     }
16974     {
16975         if (temp8)
16976         delete arg8;
16977     }
16978     return NULL;
16979 }
16980
16981
16982 static PyObject *_wrap_MDIParentFrame_ActivateNext(PyObject *, PyObject *args, PyObject *kwargs) {
16983     PyObject *resultobj;
16984     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16985     PyObject * obj0 = 0 ;
16986     char *kwnames[] = {
16987         (char *) "self", NULL
16988     };
16989
16990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivateNext",kwnames,&obj0)) goto fail;
16991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16992     if (SWIG_arg_fail(1)) SWIG_fail;
16993     {
16994         PyThreadState* __tstate = wxPyBeginAllowThreads();
16995         (arg1)->ActivateNext();
16996
16997         wxPyEndAllowThreads(__tstate);
16998         if (PyErr_Occurred()) SWIG_fail;
16999     }
17000     Py_INCREF(Py_None); resultobj = Py_None;
17001     return resultobj;
17002     fail:
17003     return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_MDIParentFrame_ActivatePrevious(PyObject *, PyObject *args, PyObject *kwargs) {
17008     PyObject *resultobj;
17009     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17010     PyObject * obj0 = 0 ;
17011     char *kwnames[] = {
17012         (char *) "self", NULL
17013     };
17014
17015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivatePrevious",kwnames,&obj0)) goto fail;
17016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17017     if (SWIG_arg_fail(1)) SWIG_fail;
17018     {
17019         PyThreadState* __tstate = wxPyBeginAllowThreads();
17020         (arg1)->ActivatePrevious();
17021
17022         wxPyEndAllowThreads(__tstate);
17023         if (PyErr_Occurred()) SWIG_fail;
17024     }
17025     Py_INCREF(Py_None); resultobj = Py_None;
17026     return resultobj;
17027     fail:
17028     return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MDIParentFrame_ArrangeIcons(PyObject *, PyObject *args, PyObject *kwargs) {
17033     PyObject *resultobj;
17034     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17035     PyObject * obj0 = 0 ;
17036     char *kwnames[] = {
17037         (char *) "self", NULL
17038     };
17039
17040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ArrangeIcons",kwnames,&obj0)) goto fail;
17041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17042     if (SWIG_arg_fail(1)) SWIG_fail;
17043     {
17044         PyThreadState* __tstate = wxPyBeginAllowThreads();
17045         (arg1)->ArrangeIcons();
17046
17047         wxPyEndAllowThreads(__tstate);
17048         if (PyErr_Occurred()) SWIG_fail;
17049     }
17050     Py_INCREF(Py_None); resultobj = Py_None;
17051     return resultobj;
17052     fail:
17053     return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_MDIParentFrame_Cascade(PyObject *, PyObject *args, PyObject *kwargs) {
17058     PyObject *resultobj;
17059     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17060     PyObject * obj0 = 0 ;
17061     char *kwnames[] = {
17062         (char *) "self", NULL
17063     };
17064
17065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Cascade",kwnames,&obj0)) goto fail;
17066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17067     if (SWIG_arg_fail(1)) SWIG_fail;
17068     {
17069         PyThreadState* __tstate = wxPyBeginAllowThreads();
17070         (arg1)->Cascade();
17071
17072         wxPyEndAllowThreads(__tstate);
17073         if (PyErr_Occurred()) SWIG_fail;
17074     }
17075     Py_INCREF(Py_None); resultobj = Py_None;
17076     return resultobj;
17077     fail:
17078     return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_MDIParentFrame_GetActiveChild(PyObject *, PyObject *args, PyObject *kwargs) {
17083     PyObject *resultobj;
17084     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17085     wxMDIChildFrame *result;
17086     PyObject * obj0 = 0 ;
17087     char *kwnames[] = {
17088         (char *) "self", NULL
17089     };
17090
17091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetActiveChild",kwnames,&obj0)) goto fail;
17092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17093     if (SWIG_arg_fail(1)) SWIG_fail;
17094     {
17095         PyThreadState* __tstate = wxPyBeginAllowThreads();
17096         result = (wxMDIChildFrame *)(arg1)->GetActiveChild();
17097
17098         wxPyEndAllowThreads(__tstate);
17099         if (PyErr_Occurred()) SWIG_fail;
17100     }
17101     {
17102         resultobj = wxPyMake_wxObject(result, 0);
17103     }
17104     return resultobj;
17105     fail:
17106     return NULL;
17107 }
17108
17109
17110 static PyObject *_wrap_MDIParentFrame_GetClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17111     PyObject *resultobj;
17112     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17113     wxMDIClientWindow *result;
17114     PyObject * obj0 = 0 ;
17115     char *kwnames[] = {
17116         (char *) "self", NULL
17117     };
17118
17119     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetClientWindow",kwnames,&obj0)) goto fail;
17120     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17121     if (SWIG_arg_fail(1)) SWIG_fail;
17122     {
17123         PyThreadState* __tstate = wxPyBeginAllowThreads();
17124         result = (wxMDIClientWindow *)(arg1)->GetClientWindow();
17125
17126         wxPyEndAllowThreads(__tstate);
17127         if (PyErr_Occurred()) SWIG_fail;
17128     }
17129     {
17130         resultobj = wxPyMake_wxObject(result, 0);
17131     }
17132     return resultobj;
17133     fail:
17134     return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_MDIParentFrame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17139     PyObject *resultobj;
17140     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17141     wxWindow *result;
17142     PyObject * obj0 = 0 ;
17143     char *kwnames[] = {
17144         (char *) "self", NULL
17145     };
17146
17147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetToolBar",kwnames,&obj0)) goto fail;
17148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17149     if (SWIG_arg_fail(1)) SWIG_fail;
17150     {
17151         PyThreadState* __tstate = wxPyBeginAllowThreads();
17152         result = (wxWindow *)(arg1)->GetToolBar();
17153
17154         wxPyEndAllowThreads(__tstate);
17155         if (PyErr_Occurred()) SWIG_fail;
17156     }
17157     {
17158         resultobj = wxPyMake_wxObject(result, 0);
17159     }
17160     return resultobj;
17161     fail:
17162     return NULL;
17163 }
17164
17165
17166 static PyObject *_wrap_MDIParentFrame_Tile(PyObject *, PyObject *args, PyObject *kwargs) {
17167     PyObject *resultobj;
17168     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17169     wxOrientation arg2 = (wxOrientation) wxHORIZONTAL ;
17170     PyObject * obj0 = 0 ;
17171     PyObject * obj1 = 0 ;
17172     char *kwnames[] = {
17173         (char *) "self",(char *) "orient", NULL
17174     };
17175
17176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIParentFrame_Tile",kwnames,&obj0,&obj1)) goto fail;
17177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17178     if (SWIG_arg_fail(1)) SWIG_fail;
17179     if (obj1) {
17180         {
17181             arg2 = (wxOrientation)(SWIG_As_int(obj1));
17182             if (SWIG_arg_fail(2)) SWIG_fail;
17183         }
17184     }
17185     {
17186         PyThreadState* __tstate = wxPyBeginAllowThreads();
17187         (arg1)->Tile((wxOrientation )arg2);
17188
17189         wxPyEndAllowThreads(__tstate);
17190         if (PyErr_Occurred()) SWIG_fail;
17191     }
17192     Py_INCREF(Py_None); resultobj = Py_None;
17193     return resultobj;
17194     fail:
17195     return NULL;
17196 }
17197
17198
17199 static PyObject * MDIParentFrame_swigregister(PyObject *, PyObject *args) {
17200     PyObject *obj;
17201     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17202     SWIG_TypeClientData(SWIGTYPE_p_wxMDIParentFrame, obj);
17203     Py_INCREF(obj);
17204     return Py_BuildValue((char *)"");
17205 }
17206 static PyObject *_wrap_new_MDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17207     PyObject *resultobj;
17208     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17209     int arg2 = (int) (int)-1 ;
17210     wxString const &arg3_defvalue = wxPyEmptyString ;
17211     wxString *arg3 = (wxString *) &arg3_defvalue ;
17212     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17213     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17214     wxSize const &arg5_defvalue = wxDefaultSize ;
17215     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17216     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
17217     wxString const &arg7_defvalue = wxPyFrameNameStr ;
17218     wxString *arg7 = (wxString *) &arg7_defvalue ;
17219     wxMDIChildFrame *result;
17220     bool temp3 = false ;
17221     wxPoint temp4 ;
17222     wxSize temp5 ;
17223     bool temp7 = false ;
17224     PyObject * obj0 = 0 ;
17225     PyObject * obj1 = 0 ;
17226     PyObject * obj2 = 0 ;
17227     PyObject * obj3 = 0 ;
17228     PyObject * obj4 = 0 ;
17229     PyObject * obj5 = 0 ;
17230     PyObject * obj6 = 0 ;
17231     char *kwnames[] = {
17232         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17233     };
17234
17235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIChildFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17236     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17237     if (SWIG_arg_fail(1)) SWIG_fail;
17238     if (obj1) {
17239         {
17240             arg2 = (int const)(SWIG_As_int(obj1));
17241             if (SWIG_arg_fail(2)) SWIG_fail;
17242         }
17243     }
17244     if (obj2) {
17245         {
17246             arg3 = wxString_in_helper(obj2);
17247             if (arg3 == NULL) SWIG_fail;
17248             temp3 = true;
17249         }
17250     }
17251     if (obj3) {
17252         {
17253             arg4 = &temp4;
17254             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17255         }
17256     }
17257     if (obj4) {
17258         {
17259             arg5 = &temp5;
17260             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17261         }
17262     }
17263     if (obj5) {
17264         {
17265             arg6 = (long)(SWIG_As_long(obj5));
17266             if (SWIG_arg_fail(6)) SWIG_fail;
17267         }
17268     }
17269     if (obj6) {
17270         {
17271             arg7 = wxString_in_helper(obj6);
17272             if (arg7 == NULL) SWIG_fail;
17273             temp7 = true;
17274         }
17275     }
17276     {
17277         if (!wxPyCheckForApp()) SWIG_fail;
17278         PyThreadState* __tstate = wxPyBeginAllowThreads();
17279         result = (wxMDIChildFrame *)new wxMDIChildFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17280
17281         wxPyEndAllowThreads(__tstate);
17282         if (PyErr_Occurred()) SWIG_fail;
17283     }
17284     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17285     {
17286         if (temp3)
17287         delete arg3;
17288     }
17289     {
17290         if (temp7)
17291         delete arg7;
17292     }
17293     return resultobj;
17294     fail:
17295     {
17296         if (temp3)
17297         delete arg3;
17298     }
17299     {
17300         if (temp7)
17301         delete arg7;
17302     }
17303     return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_new_PreMDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17308     PyObject *resultobj;
17309     wxMDIChildFrame *result;
17310     char *kwnames[] = {
17311         NULL
17312     };
17313
17314     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIChildFrame",kwnames)) goto fail;
17315     {
17316         if (!wxPyCheckForApp()) SWIG_fail;
17317         PyThreadState* __tstate = wxPyBeginAllowThreads();
17318         result = (wxMDIChildFrame *)new wxMDIChildFrame();
17319
17320         wxPyEndAllowThreads(__tstate);
17321         if (PyErr_Occurred()) SWIG_fail;
17322     }
17323     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17324     return resultobj;
17325     fail:
17326     return NULL;
17327 }
17328
17329
17330 static PyObject *_wrap_MDIChildFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17331     PyObject *resultobj;
17332     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17333     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17334     int arg3 = (int) (int)-1 ;
17335     wxString const &arg4_defvalue = wxPyEmptyString ;
17336     wxString *arg4 = (wxString *) &arg4_defvalue ;
17337     wxPoint const &arg5_defvalue = wxDefaultPosition ;
17338     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
17339     wxSize const &arg6_defvalue = wxDefaultSize ;
17340     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
17341     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
17342     wxString const &arg8_defvalue = wxPyFrameNameStr ;
17343     wxString *arg8 = (wxString *) &arg8_defvalue ;
17344     bool result;
17345     bool temp4 = false ;
17346     wxPoint temp5 ;
17347     wxSize temp6 ;
17348     bool temp8 = false ;
17349     PyObject * obj0 = 0 ;
17350     PyObject * obj1 = 0 ;
17351     PyObject * obj2 = 0 ;
17352     PyObject * obj3 = 0 ;
17353     PyObject * obj4 = 0 ;
17354     PyObject * obj5 = 0 ;
17355     PyObject * obj6 = 0 ;
17356     PyObject * obj7 = 0 ;
17357     char *kwnames[] = {
17358         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17359     };
17360
17361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIChildFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
17362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17363     if (SWIG_arg_fail(1)) SWIG_fail;
17364     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17365     if (SWIG_arg_fail(2)) SWIG_fail;
17366     if (obj2) {
17367         {
17368             arg3 = (int const)(SWIG_As_int(obj2));
17369             if (SWIG_arg_fail(3)) SWIG_fail;
17370         }
17371     }
17372     if (obj3) {
17373         {
17374             arg4 = wxString_in_helper(obj3);
17375             if (arg4 == NULL) SWIG_fail;
17376             temp4 = true;
17377         }
17378     }
17379     if (obj4) {
17380         {
17381             arg5 = &temp5;
17382             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17383         }
17384     }
17385     if (obj5) {
17386         {
17387             arg6 = &temp6;
17388             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
17389         }
17390     }
17391     if (obj6) {
17392         {
17393             arg7 = (long)(SWIG_As_long(obj6));
17394             if (SWIG_arg_fail(7)) SWIG_fail;
17395         }
17396     }
17397     if (obj7) {
17398         {
17399             arg8 = wxString_in_helper(obj7);
17400             if (arg8 == NULL) SWIG_fail;
17401             temp8 = true;
17402         }
17403     }
17404     {
17405         PyThreadState* __tstate = wxPyBeginAllowThreads();
17406         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17407
17408         wxPyEndAllowThreads(__tstate);
17409         if (PyErr_Occurred()) SWIG_fail;
17410     }
17411     {
17412         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17413     }
17414     {
17415         if (temp4)
17416         delete arg4;
17417     }
17418     {
17419         if (temp8)
17420         delete arg8;
17421     }
17422     return resultobj;
17423     fail:
17424     {
17425         if (temp4)
17426         delete arg4;
17427     }
17428     {
17429         if (temp8)
17430         delete arg8;
17431     }
17432     return NULL;
17433 }
17434
17435
17436 static PyObject *_wrap_MDIChildFrame_Activate(PyObject *, PyObject *args, PyObject *kwargs) {
17437     PyObject *resultobj;
17438     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17439     PyObject * obj0 = 0 ;
17440     char *kwnames[] = {
17441         (char *) "self", NULL
17442     };
17443
17444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Activate",kwnames,&obj0)) goto fail;
17445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17446     if (SWIG_arg_fail(1)) SWIG_fail;
17447     {
17448         PyThreadState* __tstate = wxPyBeginAllowThreads();
17449         (arg1)->Activate();
17450
17451         wxPyEndAllowThreads(__tstate);
17452         if (PyErr_Occurred()) SWIG_fail;
17453     }
17454     Py_INCREF(Py_None); resultobj = Py_None;
17455     return resultobj;
17456     fail:
17457     return NULL;
17458 }
17459
17460
17461 static PyObject *_wrap_MDIChildFrame_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
17462     PyObject *resultobj;
17463     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17464     bool arg2 = (bool) true ;
17465     PyObject * obj0 = 0 ;
17466     PyObject * obj1 = 0 ;
17467     char *kwnames[] = {
17468         (char *) "self",(char *) "maximize", NULL
17469     };
17470
17471     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIChildFrame_Maximize",kwnames,&obj0,&obj1)) goto fail;
17472     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17473     if (SWIG_arg_fail(1)) SWIG_fail;
17474     if (obj1) {
17475         {
17476             arg2 = (bool)(SWIG_As_bool(obj1));
17477             if (SWIG_arg_fail(2)) SWIG_fail;
17478         }
17479     }
17480     {
17481         PyThreadState* __tstate = wxPyBeginAllowThreads();
17482         (arg1)->Maximize(arg2);
17483
17484         wxPyEndAllowThreads(__tstate);
17485         if (PyErr_Occurred()) SWIG_fail;
17486     }
17487     Py_INCREF(Py_None); resultobj = Py_None;
17488     return resultobj;
17489     fail:
17490     return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_MDIChildFrame_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
17495     PyObject *resultobj;
17496     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17497     PyObject * obj0 = 0 ;
17498     char *kwnames[] = {
17499         (char *) "self", NULL
17500     };
17501
17502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Restore",kwnames,&obj0)) goto fail;
17503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17504     if (SWIG_arg_fail(1)) SWIG_fail;
17505     {
17506         PyThreadState* __tstate = wxPyBeginAllowThreads();
17507         (arg1)->Restore();
17508
17509         wxPyEndAllowThreads(__tstate);
17510         if (PyErr_Occurred()) SWIG_fail;
17511     }
17512     Py_INCREF(Py_None); resultobj = Py_None;
17513     return resultobj;
17514     fail:
17515     return NULL;
17516 }
17517
17518
17519 static PyObject * MDIChildFrame_swigregister(PyObject *, PyObject *args) {
17520     PyObject *obj;
17521     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17522     SWIG_TypeClientData(SWIGTYPE_p_wxMDIChildFrame, obj);
17523     Py_INCREF(obj);
17524     return Py_BuildValue((char *)"");
17525 }
17526 static PyObject *_wrap_new_MDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17527     PyObject *resultobj;
17528     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17529     long arg2 = (long) 0 ;
17530     wxMDIClientWindow *result;
17531     PyObject * obj0 = 0 ;
17532     PyObject * obj1 = 0 ;
17533     char *kwnames[] = {
17534         (char *) "parent",(char *) "style", NULL
17535     };
17536
17537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_MDIClientWindow",kwnames,&obj0,&obj1)) goto fail;
17538     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17539     if (SWIG_arg_fail(1)) SWIG_fail;
17540     if (obj1) {
17541         {
17542             arg2 = (long)(SWIG_As_long(obj1));
17543             if (SWIG_arg_fail(2)) SWIG_fail;
17544         }
17545     }
17546     {
17547         if (!wxPyCheckForApp()) SWIG_fail;
17548         PyThreadState* __tstate = wxPyBeginAllowThreads();
17549         result = (wxMDIClientWindow *)new wxMDIClientWindow(arg1,arg2);
17550
17551         wxPyEndAllowThreads(__tstate);
17552         if (PyErr_Occurred()) SWIG_fail;
17553     }
17554     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17555     return resultobj;
17556     fail:
17557     return NULL;
17558 }
17559
17560
17561 static PyObject *_wrap_new_PreMDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17562     PyObject *resultobj;
17563     wxMDIClientWindow *result;
17564     char *kwnames[] = {
17565         NULL
17566     };
17567
17568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIClientWindow",kwnames)) goto fail;
17569     {
17570         if (!wxPyCheckForApp()) SWIG_fail;
17571         PyThreadState* __tstate = wxPyBeginAllowThreads();
17572         result = (wxMDIClientWindow *)new wxMDIClientWindow();
17573
17574         wxPyEndAllowThreads(__tstate);
17575         if (PyErr_Occurred()) SWIG_fail;
17576     }
17577     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17578     return resultobj;
17579     fail:
17580     return NULL;
17581 }
17582
17583
17584 static PyObject *_wrap_MDIClientWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17585     PyObject *resultobj;
17586     wxMDIClientWindow *arg1 = (wxMDIClientWindow *) 0 ;
17587     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17588     long arg3 = (long) 0 ;
17589     bool result;
17590     PyObject * obj0 = 0 ;
17591     PyObject * obj1 = 0 ;
17592     PyObject * obj2 = 0 ;
17593     char *kwnames[] = {
17594         (char *) "self",(char *) "parent",(char *) "style", NULL
17595     };
17596
17597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MDIClientWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
17598     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIClientWindow, SWIG_POINTER_EXCEPTION | 0);
17599     if (SWIG_arg_fail(1)) SWIG_fail;
17600     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17601     if (SWIG_arg_fail(2)) SWIG_fail;
17602     if (obj2) {
17603         {
17604             arg3 = (long)(SWIG_As_long(obj2));
17605             if (SWIG_arg_fail(3)) SWIG_fail;
17606         }
17607     }
17608     {
17609         PyThreadState* __tstate = wxPyBeginAllowThreads();
17610         result = (bool)(arg1)->Create(arg2,arg3);
17611
17612         wxPyEndAllowThreads(__tstate);
17613         if (PyErr_Occurred()) SWIG_fail;
17614     }
17615     {
17616         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17617     }
17618     return resultobj;
17619     fail:
17620     return NULL;
17621 }
17622
17623
17624 static PyObject * MDIClientWindow_swigregister(PyObject *, PyObject *args) {
17625     PyObject *obj;
17626     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17627     SWIG_TypeClientData(SWIGTYPE_p_wxMDIClientWindow, obj);
17628     Py_INCREF(obj);
17629     return Py_BuildValue((char *)"");
17630 }
17631 static PyObject *_wrap_new_PyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17632     PyObject *resultobj;
17633     wxWindow *arg1 = (wxWindow *) 0 ;
17634     int arg2 = (int) (int)-1 ;
17635     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17636     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17637     wxSize const &arg4_defvalue = wxDefaultSize ;
17638     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17639     long arg5 = (long) 0 ;
17640     wxString const &arg6_defvalue = wxPyPanelNameStr ;
17641     wxString *arg6 = (wxString *) &arg6_defvalue ;
17642     wxPyWindow *result;
17643     wxPoint temp3 ;
17644     wxSize temp4 ;
17645     bool temp6 = false ;
17646     PyObject * obj0 = 0 ;
17647     PyObject * obj1 = 0 ;
17648     PyObject * obj2 = 0 ;
17649     PyObject * obj3 = 0 ;
17650     PyObject * obj4 = 0 ;
17651     PyObject * obj5 = 0 ;
17652     char *kwnames[] = {
17653         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17654     };
17655
17656     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17657     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17658     if (SWIG_arg_fail(1)) SWIG_fail;
17659     if (obj1) {
17660         {
17661             arg2 = (int const)(SWIG_As_int(obj1));
17662             if (SWIG_arg_fail(2)) SWIG_fail;
17663         }
17664     }
17665     if (obj2) {
17666         {
17667             arg3 = &temp3;
17668             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17669         }
17670     }
17671     if (obj3) {
17672         {
17673             arg4 = &temp4;
17674             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17675         }
17676     }
17677     if (obj4) {
17678         {
17679             arg5 = (long)(SWIG_As_long(obj4));
17680             if (SWIG_arg_fail(5)) SWIG_fail;
17681         }
17682     }
17683     if (obj5) {
17684         {
17685             arg6 = wxString_in_helper(obj5);
17686             if (arg6 == NULL) SWIG_fail;
17687             temp6 = true;
17688         }
17689     }
17690     {
17691         if (!wxPyCheckForApp()) SWIG_fail;
17692         PyThreadState* __tstate = wxPyBeginAllowThreads();
17693         result = (wxPyWindow *)new wxPyWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17694
17695         wxPyEndAllowThreads(__tstate);
17696         if (PyErr_Occurred()) SWIG_fail;
17697     }
17698     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17699     {
17700         if (temp6)
17701         delete arg6;
17702     }
17703     return resultobj;
17704     fail:
17705     {
17706         if (temp6)
17707         delete arg6;
17708     }
17709     return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_new_PrePyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17714     PyObject *resultobj;
17715     wxPyWindow *result;
17716     char *kwnames[] = {
17717         NULL
17718     };
17719
17720     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyWindow",kwnames)) goto fail;
17721     {
17722         if (!wxPyCheckForApp()) SWIG_fail;
17723         PyThreadState* __tstate = wxPyBeginAllowThreads();
17724         result = (wxPyWindow *)new wxPyWindow();
17725
17726         wxPyEndAllowThreads(__tstate);
17727         if (PyErr_Occurred()) SWIG_fail;
17728     }
17729     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17730     return resultobj;
17731     fail:
17732     return NULL;
17733 }
17734
17735
17736 static PyObject *_wrap_PyWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17737     PyObject *resultobj;
17738     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17739     PyObject *arg2 = (PyObject *) 0 ;
17740     PyObject *arg3 = (PyObject *) 0 ;
17741     PyObject * obj0 = 0 ;
17742     PyObject * obj1 = 0 ;
17743     PyObject * obj2 = 0 ;
17744     char *kwnames[] = {
17745         (char *) "self",(char *) "self",(char *) "_class", NULL
17746     };
17747
17748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17749     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17750     if (SWIG_arg_fail(1)) SWIG_fail;
17751     arg2 = obj1;
17752     arg3 = obj2;
17753     {
17754         PyThreadState* __tstate = wxPyBeginAllowThreads();
17755         (arg1)->_setCallbackInfo(arg2,arg3);
17756
17757         wxPyEndAllowThreads(__tstate);
17758         if (PyErr_Occurred()) SWIG_fail;
17759     }
17760     Py_INCREF(Py_None); resultobj = Py_None;
17761     return resultobj;
17762     fail:
17763     return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_PyWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
17768     PyObject *resultobj;
17769     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17770     wxSize *arg2 = 0 ;
17771     wxSize temp2 ;
17772     PyObject * obj0 = 0 ;
17773     PyObject * obj1 = 0 ;
17774     char *kwnames[] = {
17775         (char *) "self",(char *) "size", NULL
17776     };
17777
17778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
17779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17780     if (SWIG_arg_fail(1)) SWIG_fail;
17781     {
17782         arg2 = &temp2;
17783         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17784     }
17785     {
17786         PyThreadState* __tstate = wxPyBeginAllowThreads();
17787         (arg1)->SetBestSize((wxSize const &)*arg2);
17788
17789         wxPyEndAllowThreads(__tstate);
17790         if (PyErr_Occurred()) SWIG_fail;
17791     }
17792     Py_INCREF(Py_None); resultobj = Py_None;
17793     return resultobj;
17794     fail:
17795     return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_PyWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17800     PyObject *resultobj;
17801     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17802     int arg2 ;
17803     int arg3 ;
17804     int arg4 ;
17805     int arg5 ;
17806     PyObject * obj0 = 0 ;
17807     PyObject * obj1 = 0 ;
17808     PyObject * obj2 = 0 ;
17809     PyObject * obj3 = 0 ;
17810     PyObject * obj4 = 0 ;
17811     char *kwnames[] = {
17812         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17813     };
17814
17815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17817     if (SWIG_arg_fail(1)) SWIG_fail;
17818     {
17819         arg2 = (int)(SWIG_As_int(obj1));
17820         if (SWIG_arg_fail(2)) SWIG_fail;
17821     }
17822     {
17823         arg3 = (int)(SWIG_As_int(obj2));
17824         if (SWIG_arg_fail(3)) SWIG_fail;
17825     }
17826     {
17827         arg4 = (int)(SWIG_As_int(obj3));
17828         if (SWIG_arg_fail(4)) SWIG_fail;
17829     }
17830     {
17831         arg5 = (int)(SWIG_As_int(obj4));
17832         if (SWIG_arg_fail(5)) SWIG_fail;
17833     }
17834     {
17835         PyThreadState* __tstate = wxPyBeginAllowThreads();
17836         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
17837
17838         wxPyEndAllowThreads(__tstate);
17839         if (PyErr_Occurred()) SWIG_fail;
17840     }
17841     Py_INCREF(Py_None); resultobj = Py_None;
17842     return resultobj;
17843     fail:
17844     return NULL;
17845 }
17846
17847
17848 static PyObject *_wrap_PyWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17849     PyObject *resultobj;
17850     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17851     int arg2 ;
17852     int arg3 ;
17853     int arg4 ;
17854     int arg5 ;
17855     int arg6 = (int) wxSIZE_AUTO ;
17856     PyObject * obj0 = 0 ;
17857     PyObject * obj1 = 0 ;
17858     PyObject * obj2 = 0 ;
17859     PyObject * obj3 = 0 ;
17860     PyObject * obj4 = 0 ;
17861     PyObject * obj5 = 0 ;
17862     char *kwnames[] = {
17863         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
17864     };
17865
17866     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17867     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17868     if (SWIG_arg_fail(1)) SWIG_fail;
17869     {
17870         arg2 = (int)(SWIG_As_int(obj1));
17871         if (SWIG_arg_fail(2)) SWIG_fail;
17872     }
17873     {
17874         arg3 = (int)(SWIG_As_int(obj2));
17875         if (SWIG_arg_fail(3)) SWIG_fail;
17876     }
17877     {
17878         arg4 = (int)(SWIG_As_int(obj3));
17879         if (SWIG_arg_fail(4)) SWIG_fail;
17880     }
17881     {
17882         arg5 = (int)(SWIG_As_int(obj4));
17883         if (SWIG_arg_fail(5)) SWIG_fail;
17884     }
17885     if (obj5) {
17886         {
17887             arg6 = (int)(SWIG_As_int(obj5));
17888             if (SWIG_arg_fail(6)) SWIG_fail;
17889         }
17890     }
17891     {
17892         PyThreadState* __tstate = wxPyBeginAllowThreads();
17893         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
17894
17895         wxPyEndAllowThreads(__tstate);
17896         if (PyErr_Occurred()) SWIG_fail;
17897     }
17898     Py_INCREF(Py_None); resultobj = Py_None;
17899     return resultobj;
17900     fail:
17901     return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_PyWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
17906     PyObject *resultobj;
17907     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17908     int arg2 ;
17909     int arg3 ;
17910     PyObject * obj0 = 0 ;
17911     PyObject * obj1 = 0 ;
17912     PyObject * obj2 = 0 ;
17913     char *kwnames[] = {
17914         (char *) "self",(char *) "width",(char *) "height", NULL
17915     };
17916
17917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17919     if (SWIG_arg_fail(1)) SWIG_fail;
17920     {
17921         arg2 = (int)(SWIG_As_int(obj1));
17922         if (SWIG_arg_fail(2)) SWIG_fail;
17923     }
17924     {
17925         arg3 = (int)(SWIG_As_int(obj2));
17926         if (SWIG_arg_fail(3)) SWIG_fail;
17927     }
17928     {
17929         PyThreadState* __tstate = wxPyBeginAllowThreads();
17930         (arg1)->base_DoSetClientSize(arg2,arg3);
17931
17932         wxPyEndAllowThreads(__tstate);
17933         if (PyErr_Occurred()) SWIG_fail;
17934     }
17935     Py_INCREF(Py_None); resultobj = Py_None;
17936     return resultobj;
17937     fail:
17938     return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_PyWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
17943     PyObject *resultobj;
17944     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17945     int arg2 ;
17946     int arg3 ;
17947     PyObject * obj0 = 0 ;
17948     PyObject * obj1 = 0 ;
17949     PyObject * obj2 = 0 ;
17950     char *kwnames[] = {
17951         (char *) "self",(char *) "x",(char *) "y", NULL
17952     };
17953
17954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17955     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17956     if (SWIG_arg_fail(1)) SWIG_fail;
17957     {
17958         arg2 = (int)(SWIG_As_int(obj1));
17959         if (SWIG_arg_fail(2)) SWIG_fail;
17960     }
17961     {
17962         arg3 = (int)(SWIG_As_int(obj2));
17963         if (SWIG_arg_fail(3)) SWIG_fail;
17964     }
17965     {
17966         PyThreadState* __tstate = wxPyBeginAllowThreads();
17967         (arg1)->base_DoSetVirtualSize(arg2,arg3);
17968
17969         wxPyEndAllowThreads(__tstate);
17970         if (PyErr_Occurred()) SWIG_fail;
17971     }
17972     Py_INCREF(Py_None); resultobj = Py_None;
17973     return resultobj;
17974     fail:
17975     return NULL;
17976 }
17977
17978
17979 static PyObject *_wrap_PyWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17980     PyObject *resultobj;
17981     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17982     int *arg2 = (int *) 0 ;
17983     int *arg3 = (int *) 0 ;
17984     int temp2 ;
17985     int res2 = 0 ;
17986     int temp3 ;
17987     int res3 = 0 ;
17988     PyObject * obj0 = 0 ;
17989     char *kwnames[] = {
17990         (char *) "self", NULL
17991     };
17992
17993     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17994     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
17996     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17997     if (SWIG_arg_fail(1)) SWIG_fail;
17998     {
17999         PyThreadState* __tstate = wxPyBeginAllowThreads();
18000         ((wxPyWindow const *)arg1)->base_DoGetSize(arg2,arg3);
18001
18002         wxPyEndAllowThreads(__tstate);
18003         if (PyErr_Occurred()) SWIG_fail;
18004     }
18005     Py_INCREF(Py_None); resultobj = Py_None;
18006     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18007     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18008     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18009     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18010     return resultobj;
18011     fail:
18012     return NULL;
18013 }
18014
18015
18016 static PyObject *_wrap_PyWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18017     PyObject *resultobj;
18018     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18019     int *arg2 = (int *) 0 ;
18020     int *arg3 = (int *) 0 ;
18021     int temp2 ;
18022     int res2 = 0 ;
18023     int temp3 ;
18024     int res3 = 0 ;
18025     PyObject * obj0 = 0 ;
18026     char *kwnames[] = {
18027         (char *) "self", NULL
18028     };
18029
18030     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18031     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18034     if (SWIG_arg_fail(1)) SWIG_fail;
18035     {
18036         PyThreadState* __tstate = wxPyBeginAllowThreads();
18037         ((wxPyWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
18038
18039         wxPyEndAllowThreads(__tstate);
18040         if (PyErr_Occurred()) SWIG_fail;
18041     }
18042     Py_INCREF(Py_None); resultobj = Py_None;
18043     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18044     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18045     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18046     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18047     return resultobj;
18048     fail:
18049     return NULL;
18050 }
18051
18052
18053 static PyObject *_wrap_PyWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18054     PyObject *resultobj;
18055     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18056     int *arg2 = (int *) 0 ;
18057     int *arg3 = (int *) 0 ;
18058     int temp2 ;
18059     int res2 = 0 ;
18060     int temp3 ;
18061     int res3 = 0 ;
18062     PyObject * obj0 = 0 ;
18063     char *kwnames[] = {
18064         (char *) "self", NULL
18065     };
18066
18067     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18068     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
18070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18071     if (SWIG_arg_fail(1)) SWIG_fail;
18072     {
18073         PyThreadState* __tstate = wxPyBeginAllowThreads();
18074         ((wxPyWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
18075
18076         wxPyEndAllowThreads(__tstate);
18077         if (PyErr_Occurred()) SWIG_fail;
18078     }
18079     Py_INCREF(Py_None); resultobj = Py_None;
18080     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18081     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18082     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18083     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18084     return resultobj;
18085     fail:
18086     return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_PyWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18091     PyObject *resultobj;
18092     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18093     wxSize result;
18094     PyObject * obj0 = 0 ;
18095     char *kwnames[] = {
18096         (char *) "self", NULL
18097     };
18098
18099     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18100     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18101     if (SWIG_arg_fail(1)) SWIG_fail;
18102     {
18103         PyThreadState* __tstate = wxPyBeginAllowThreads();
18104         result = ((wxPyWindow const *)arg1)->base_DoGetVirtualSize();
18105
18106         wxPyEndAllowThreads(__tstate);
18107         if (PyErr_Occurred()) SWIG_fail;
18108     }
18109     {
18110         wxSize * resultptr;
18111         resultptr = new wxSize((wxSize &)(result));
18112         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18113     }
18114     return resultobj;
18115     fail:
18116     return NULL;
18117 }
18118
18119
18120 static PyObject *_wrap_PyWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18121     PyObject *resultobj;
18122     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18123     wxSize result;
18124     PyObject * obj0 = 0 ;
18125     char *kwnames[] = {
18126         (char *) "self", NULL
18127     };
18128
18129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18131     if (SWIG_arg_fail(1)) SWIG_fail;
18132     {
18133         PyThreadState* __tstate = wxPyBeginAllowThreads();
18134         result = ((wxPyWindow const *)arg1)->base_DoGetBestSize();
18135
18136         wxPyEndAllowThreads(__tstate);
18137         if (PyErr_Occurred()) SWIG_fail;
18138     }
18139     {
18140         wxSize * resultptr;
18141         resultptr = new wxSize((wxSize &)(result));
18142         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18143     }
18144     return resultobj;
18145     fail:
18146     return NULL;
18147 }
18148
18149
18150 static PyObject *_wrap_PyWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
18151     PyObject *resultobj;
18152     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18153     PyObject * obj0 = 0 ;
18154     char *kwnames[] = {
18155         (char *) "self", NULL
18156     };
18157
18158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_InitDialog",kwnames,&obj0)) goto fail;
18159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18160     if (SWIG_arg_fail(1)) SWIG_fail;
18161     {
18162         PyThreadState* __tstate = wxPyBeginAllowThreads();
18163         (arg1)->base_InitDialog();
18164
18165         wxPyEndAllowThreads(__tstate);
18166         if (PyErr_Occurred()) SWIG_fail;
18167     }
18168     Py_INCREF(Py_None); resultobj = Py_None;
18169     return resultobj;
18170     fail:
18171     return NULL;
18172 }
18173
18174
18175 static PyObject *_wrap_PyWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18176     PyObject *resultobj;
18177     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18178     bool result;
18179     PyObject * obj0 = 0 ;
18180     char *kwnames[] = {
18181         (char *) "self", NULL
18182     };
18183
18184     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
18185     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18186     if (SWIG_arg_fail(1)) SWIG_fail;
18187     {
18188         PyThreadState* __tstate = wxPyBeginAllowThreads();
18189         result = (bool)(arg1)->base_TransferDataToWindow();
18190
18191         wxPyEndAllowThreads(__tstate);
18192         if (PyErr_Occurred()) SWIG_fail;
18193     }
18194     {
18195         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18196     }
18197     return resultobj;
18198     fail:
18199     return NULL;
18200 }
18201
18202
18203 static PyObject *_wrap_PyWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18204     PyObject *resultobj;
18205     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18206     bool result;
18207     PyObject * obj0 = 0 ;
18208     char *kwnames[] = {
18209         (char *) "self", NULL
18210     };
18211
18212     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
18213     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18214     if (SWIG_arg_fail(1)) SWIG_fail;
18215     {
18216         PyThreadState* __tstate = wxPyBeginAllowThreads();
18217         result = (bool)(arg1)->base_TransferDataFromWindow();
18218
18219         wxPyEndAllowThreads(__tstate);
18220         if (PyErr_Occurred()) SWIG_fail;
18221     }
18222     {
18223         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18224     }
18225     return resultobj;
18226     fail:
18227     return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_PyWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
18232     PyObject *resultobj;
18233     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18234     bool result;
18235     PyObject * obj0 = 0 ;
18236     char *kwnames[] = {
18237         (char *) "self", NULL
18238     };
18239
18240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_Validate",kwnames,&obj0)) goto fail;
18241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18242     if (SWIG_arg_fail(1)) SWIG_fail;
18243     {
18244         PyThreadState* __tstate = wxPyBeginAllowThreads();
18245         result = (bool)(arg1)->base_Validate();
18246
18247         wxPyEndAllowThreads(__tstate);
18248         if (PyErr_Occurred()) SWIG_fail;
18249     }
18250     {
18251         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18252     }
18253     return resultobj;
18254     fail:
18255     return NULL;
18256 }
18257
18258
18259 static PyObject *_wrap_PyWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
18260     PyObject *resultobj;
18261     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18262     bool result;
18263     PyObject * obj0 = 0 ;
18264     char *kwnames[] = {
18265         (char *) "self", NULL
18266     };
18267
18268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
18269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18270     if (SWIG_arg_fail(1)) SWIG_fail;
18271     {
18272         PyThreadState* __tstate = wxPyBeginAllowThreads();
18273         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocus();
18274
18275         wxPyEndAllowThreads(__tstate);
18276         if (PyErr_Occurred()) SWIG_fail;
18277     }
18278     {
18279         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18280     }
18281     return resultobj;
18282     fail:
18283     return NULL;
18284 }
18285
18286
18287 static PyObject *_wrap_PyWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
18288     PyObject *resultobj;
18289     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18290     bool result;
18291     PyObject * obj0 = 0 ;
18292     char *kwnames[] = {
18293         (char *) "self", NULL
18294     };
18295
18296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
18297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18298     if (SWIG_arg_fail(1)) SWIG_fail;
18299     {
18300         PyThreadState* __tstate = wxPyBeginAllowThreads();
18301         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
18302
18303         wxPyEndAllowThreads(__tstate);
18304         if (PyErr_Occurred()) SWIG_fail;
18305     }
18306     {
18307         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18308     }
18309     return resultobj;
18310     fail:
18311     return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_PyWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
18316     PyObject *resultobj;
18317     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18318     wxSize result;
18319     PyObject * obj0 = 0 ;
18320     char *kwnames[] = {
18321         (char *) "self", NULL
18322     };
18323
18324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
18325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18326     if (SWIG_arg_fail(1)) SWIG_fail;
18327     {
18328         PyThreadState* __tstate = wxPyBeginAllowThreads();
18329         result = ((wxPyWindow const *)arg1)->base_GetMaxSize();
18330
18331         wxPyEndAllowThreads(__tstate);
18332         if (PyErr_Occurred()) SWIG_fail;
18333     }
18334     {
18335         wxSize * resultptr;
18336         resultptr = new wxSize((wxSize &)(result));
18337         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18338     }
18339     return resultobj;
18340     fail:
18341     return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_PyWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
18346     PyObject *resultobj;
18347     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18348     wxWindow *arg2 = (wxWindow *) 0 ;
18349     PyObject * obj0 = 0 ;
18350     PyObject * obj1 = 0 ;
18351     char *kwnames[] = {
18352         (char *) "self",(char *) "child", NULL
18353     };
18354
18355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
18356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18357     if (SWIG_arg_fail(1)) SWIG_fail;
18358     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18359     if (SWIG_arg_fail(2)) SWIG_fail;
18360     {
18361         PyThreadState* __tstate = wxPyBeginAllowThreads();
18362         (arg1)->base_AddChild(arg2);
18363
18364         wxPyEndAllowThreads(__tstate);
18365         if (PyErr_Occurred()) SWIG_fail;
18366     }
18367     Py_INCREF(Py_None); resultobj = Py_None;
18368     return resultobj;
18369     fail:
18370     return NULL;
18371 }
18372
18373
18374 static PyObject *_wrap_PyWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
18375     PyObject *resultobj;
18376     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18377     wxWindow *arg2 = (wxWindow *) 0 ;
18378     PyObject * obj0 = 0 ;
18379     PyObject * obj1 = 0 ;
18380     char *kwnames[] = {
18381         (char *) "self",(char *) "child", NULL
18382     };
18383
18384     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
18385     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18386     if (SWIG_arg_fail(1)) SWIG_fail;
18387     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18388     if (SWIG_arg_fail(2)) SWIG_fail;
18389     {
18390         PyThreadState* __tstate = wxPyBeginAllowThreads();
18391         (arg1)->base_RemoveChild(arg2);
18392
18393         wxPyEndAllowThreads(__tstate);
18394         if (PyErr_Occurred()) SWIG_fail;
18395     }
18396     Py_INCREF(Py_None); resultobj = Py_None;
18397     return resultobj;
18398     fail:
18399     return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_PyWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
18404     PyObject *resultobj;
18405     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18406     bool result;
18407     PyObject * obj0 = 0 ;
18408     char *kwnames[] = {
18409         (char *) "self", NULL
18410     };
18411
18412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
18413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18414     if (SWIG_arg_fail(1)) SWIG_fail;
18415     {
18416         PyThreadState* __tstate = wxPyBeginAllowThreads();
18417         result = (bool)((wxPyWindow const *)arg1)->base_ShouldInheritColours();
18418
18419         wxPyEndAllowThreads(__tstate);
18420         if (PyErr_Occurred()) SWIG_fail;
18421     }
18422     {
18423         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18424     }
18425     return resultobj;
18426     fail:
18427     return NULL;
18428 }
18429
18430
18431 static PyObject *_wrap_PyWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
18432     PyObject *resultobj;
18433     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18434     wxColour *arg2 = 0 ;
18435     wxColour temp2 ;
18436     PyObject * obj0 = 0 ;
18437     PyObject * obj1 = 0 ;
18438     char *kwnames[] = {
18439         (char *) "self",(char *) "c", NULL
18440     };
18441
18442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
18443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18444     if (SWIG_arg_fail(1)) SWIG_fail;
18445     {
18446         arg2 = &temp2;
18447         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18448     }
18449     {
18450         PyThreadState* __tstate = wxPyBeginAllowThreads();
18451         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
18452
18453         wxPyEndAllowThreads(__tstate);
18454         if (PyErr_Occurred()) SWIG_fail;
18455     }
18456     Py_INCREF(Py_None); resultobj = Py_None;
18457     return resultobj;
18458     fail:
18459     return NULL;
18460 }
18461
18462
18463 static PyObject *_wrap_PyWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
18464     PyObject *resultobj;
18465     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18466     wxVisualAttributes result;
18467     PyObject * obj0 = 0 ;
18468     char *kwnames[] = {
18469         (char *) "self", NULL
18470     };
18471
18472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
18478
18479         wxPyEndAllowThreads(__tstate);
18480         if (PyErr_Occurred()) SWIG_fail;
18481     }
18482     {
18483         wxVisualAttributes * resultptr;
18484         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
18485         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
18486     }
18487     return resultobj;
18488     fail:
18489     return NULL;
18490 }
18491
18492
18493 static PyObject * PyWindow_swigregister(PyObject *, PyObject *args) {
18494     PyObject *obj;
18495     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18496     SWIG_TypeClientData(SWIGTYPE_p_wxPyWindow, obj);
18497     Py_INCREF(obj);
18498     return Py_BuildValue((char *)"");
18499 }
18500 static PyObject *_wrap_new_PyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18501     PyObject *resultobj;
18502     wxWindow *arg1 = (wxWindow *) 0 ;
18503     int arg2 = (int) (int)-1 ;
18504     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18505     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18506     wxSize const &arg4_defvalue = wxDefaultSize ;
18507     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18508     long arg5 = (long) 0 ;
18509     wxString const &arg6_defvalue = wxPyPanelNameStr ;
18510     wxString *arg6 = (wxString *) &arg6_defvalue ;
18511     wxPyPanel *result;
18512     wxPoint temp3 ;
18513     wxSize temp4 ;
18514     bool temp6 = false ;
18515     PyObject * obj0 = 0 ;
18516     PyObject * obj1 = 0 ;
18517     PyObject * obj2 = 0 ;
18518     PyObject * obj3 = 0 ;
18519     PyObject * obj4 = 0 ;
18520     PyObject * obj5 = 0 ;
18521     char *kwnames[] = {
18522         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18523     };
18524
18525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyPanel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18526     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18527     if (SWIG_arg_fail(1)) SWIG_fail;
18528     if (obj1) {
18529         {
18530             arg2 = (int const)(SWIG_As_int(obj1));
18531             if (SWIG_arg_fail(2)) SWIG_fail;
18532         }
18533     }
18534     if (obj2) {
18535         {
18536             arg3 = &temp3;
18537             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18538         }
18539     }
18540     if (obj3) {
18541         {
18542             arg4 = &temp4;
18543             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18544         }
18545     }
18546     if (obj4) {
18547         {
18548             arg5 = (long)(SWIG_As_long(obj4));
18549             if (SWIG_arg_fail(5)) SWIG_fail;
18550         }
18551     }
18552     if (obj5) {
18553         {
18554             arg6 = wxString_in_helper(obj5);
18555             if (arg6 == NULL) SWIG_fail;
18556             temp6 = true;
18557         }
18558     }
18559     {
18560         if (!wxPyCheckForApp()) SWIG_fail;
18561         PyThreadState* __tstate = wxPyBeginAllowThreads();
18562         result = (wxPyPanel *)new wxPyPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18563
18564         wxPyEndAllowThreads(__tstate);
18565         if (PyErr_Occurred()) SWIG_fail;
18566     }
18567     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18568     {
18569         if (temp6)
18570         delete arg6;
18571     }
18572     return resultobj;
18573     fail:
18574     {
18575         if (temp6)
18576         delete arg6;
18577     }
18578     return NULL;
18579 }
18580
18581
18582 static PyObject *_wrap_new_PrePyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18583     PyObject *resultobj;
18584     wxPyPanel *result;
18585     char *kwnames[] = {
18586         NULL
18587     };
18588
18589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyPanel",kwnames)) goto fail;
18590     {
18591         if (!wxPyCheckForApp()) SWIG_fail;
18592         PyThreadState* __tstate = wxPyBeginAllowThreads();
18593         result = (wxPyPanel *)new wxPyPanel();
18594
18595         wxPyEndAllowThreads(__tstate);
18596         if (PyErr_Occurred()) SWIG_fail;
18597     }
18598     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18599     return resultobj;
18600     fail:
18601     return NULL;
18602 }
18603
18604
18605 static PyObject *_wrap_PyPanel__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
18606     PyObject *resultobj;
18607     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18608     PyObject *arg2 = (PyObject *) 0 ;
18609     PyObject *arg3 = (PyObject *) 0 ;
18610     PyObject * obj0 = 0 ;
18611     PyObject * obj1 = 0 ;
18612     PyObject * obj2 = 0 ;
18613     char *kwnames[] = {
18614         (char *) "self",(char *) "self",(char *) "_class", NULL
18615     };
18616
18617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
18618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18619     if (SWIG_arg_fail(1)) SWIG_fail;
18620     arg2 = obj1;
18621     arg3 = obj2;
18622     {
18623         PyThreadState* __tstate = wxPyBeginAllowThreads();
18624         (arg1)->_setCallbackInfo(arg2,arg3);
18625
18626         wxPyEndAllowThreads(__tstate);
18627         if (PyErr_Occurred()) SWIG_fail;
18628     }
18629     Py_INCREF(Py_None); resultobj = Py_None;
18630     return resultobj;
18631     fail:
18632     return NULL;
18633 }
18634
18635
18636 static PyObject *_wrap_PyPanel_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18637     PyObject *resultobj;
18638     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18639     wxSize *arg2 = 0 ;
18640     wxSize temp2 ;
18641     PyObject * obj0 = 0 ;
18642     PyObject * obj1 = 0 ;
18643     char *kwnames[] = {
18644         (char *) "self",(char *) "size", NULL
18645     };
18646
18647     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
18648     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18649     if (SWIG_arg_fail(1)) SWIG_fail;
18650     {
18651         arg2 = &temp2;
18652         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18653     }
18654     {
18655         PyThreadState* __tstate = wxPyBeginAllowThreads();
18656         (arg1)->SetBestSize((wxSize const &)*arg2);
18657
18658         wxPyEndAllowThreads(__tstate);
18659         if (PyErr_Occurred()) SWIG_fail;
18660     }
18661     Py_INCREF(Py_None); resultobj = Py_None;
18662     return resultobj;
18663     fail:
18664     return NULL;
18665 }
18666
18667
18668 static PyObject *_wrap_PyPanel_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18669     PyObject *resultobj;
18670     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18671     int arg2 ;
18672     int arg3 ;
18673     int arg4 ;
18674     int arg5 ;
18675     PyObject * obj0 = 0 ;
18676     PyObject * obj1 = 0 ;
18677     PyObject * obj2 = 0 ;
18678     PyObject * obj3 = 0 ;
18679     PyObject * obj4 = 0 ;
18680     char *kwnames[] = {
18681         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18682     };
18683
18684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyPanel_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18685     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18686     if (SWIG_arg_fail(1)) SWIG_fail;
18687     {
18688         arg2 = (int)(SWIG_As_int(obj1));
18689         if (SWIG_arg_fail(2)) SWIG_fail;
18690     }
18691     {
18692         arg3 = (int)(SWIG_As_int(obj2));
18693         if (SWIG_arg_fail(3)) SWIG_fail;
18694     }
18695     {
18696         arg4 = (int)(SWIG_As_int(obj3));
18697         if (SWIG_arg_fail(4)) SWIG_fail;
18698     }
18699     {
18700         arg5 = (int)(SWIG_As_int(obj4));
18701         if (SWIG_arg_fail(5)) SWIG_fail;
18702     }
18703     {
18704         PyThreadState* __tstate = wxPyBeginAllowThreads();
18705         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
18706
18707         wxPyEndAllowThreads(__tstate);
18708         if (PyErr_Occurred()) SWIG_fail;
18709     }
18710     Py_INCREF(Py_None); resultobj = Py_None;
18711     return resultobj;
18712     fail:
18713     return NULL;
18714 }
18715
18716
18717 static PyObject *_wrap_PyPanel_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18718     PyObject *resultobj;
18719     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18720     int arg2 ;
18721     int arg3 ;
18722     int arg4 ;
18723     int arg5 ;
18724     int arg6 = (int) wxSIZE_AUTO ;
18725     PyObject * obj0 = 0 ;
18726     PyObject * obj1 = 0 ;
18727     PyObject * obj2 = 0 ;
18728     PyObject * obj3 = 0 ;
18729     PyObject * obj4 = 0 ;
18730     PyObject * obj5 = 0 ;
18731     char *kwnames[] = {
18732         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18733     };
18734
18735     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyPanel_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18736     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18737     if (SWIG_arg_fail(1)) SWIG_fail;
18738     {
18739         arg2 = (int)(SWIG_As_int(obj1));
18740         if (SWIG_arg_fail(2)) SWIG_fail;
18741     }
18742     {
18743         arg3 = (int)(SWIG_As_int(obj2));
18744         if (SWIG_arg_fail(3)) SWIG_fail;
18745     }
18746     {
18747         arg4 = (int)(SWIG_As_int(obj3));
18748         if (SWIG_arg_fail(4)) SWIG_fail;
18749     }
18750     {
18751         arg5 = (int)(SWIG_As_int(obj4));
18752         if (SWIG_arg_fail(5)) SWIG_fail;
18753     }
18754     if (obj5) {
18755         {
18756             arg6 = (int)(SWIG_As_int(obj5));
18757             if (SWIG_arg_fail(6)) SWIG_fail;
18758         }
18759     }
18760     {
18761         PyThreadState* __tstate = wxPyBeginAllowThreads();
18762         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18763
18764         wxPyEndAllowThreads(__tstate);
18765         if (PyErr_Occurred()) SWIG_fail;
18766     }
18767     Py_INCREF(Py_None); resultobj = Py_None;
18768     return resultobj;
18769     fail:
18770     return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_PyPanel_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18775     PyObject *resultobj;
18776     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18777     int arg2 ;
18778     int arg3 ;
18779     PyObject * obj0 = 0 ;
18780     PyObject * obj1 = 0 ;
18781     PyObject * obj2 = 0 ;
18782     char *kwnames[] = {
18783         (char *) "self",(char *) "width",(char *) "height", NULL
18784     };
18785
18786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18788     if (SWIG_arg_fail(1)) SWIG_fail;
18789     {
18790         arg2 = (int)(SWIG_As_int(obj1));
18791         if (SWIG_arg_fail(2)) SWIG_fail;
18792     }
18793     {
18794         arg3 = (int)(SWIG_As_int(obj2));
18795         if (SWIG_arg_fail(3)) SWIG_fail;
18796     }
18797     {
18798         PyThreadState* __tstate = wxPyBeginAllowThreads();
18799         (arg1)->base_DoSetClientSize(arg2,arg3);
18800
18801         wxPyEndAllowThreads(__tstate);
18802         if (PyErr_Occurred()) SWIG_fail;
18803     }
18804     Py_INCREF(Py_None); resultobj = Py_None;
18805     return resultobj;
18806     fail:
18807     return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_PyPanel_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18812     PyObject *resultobj;
18813     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18814     int arg2 ;
18815     int arg3 ;
18816     PyObject * obj0 = 0 ;
18817     PyObject * obj1 = 0 ;
18818     PyObject * obj2 = 0 ;
18819     char *kwnames[] = {
18820         (char *) "self",(char *) "x",(char *) "y", NULL
18821     };
18822
18823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18825     if (SWIG_arg_fail(1)) SWIG_fail;
18826     {
18827         arg2 = (int)(SWIG_As_int(obj1));
18828         if (SWIG_arg_fail(2)) SWIG_fail;
18829     }
18830     {
18831         arg3 = (int)(SWIG_As_int(obj2));
18832         if (SWIG_arg_fail(3)) SWIG_fail;
18833     }
18834     {
18835         PyThreadState* __tstate = wxPyBeginAllowThreads();
18836         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18837
18838         wxPyEndAllowThreads(__tstate);
18839         if (PyErr_Occurred()) SWIG_fail;
18840     }
18841     Py_INCREF(Py_None); resultobj = Py_None;
18842     return resultobj;
18843     fail:
18844     return NULL;
18845 }
18846
18847
18848 static PyObject *_wrap_PyPanel_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18849     PyObject *resultobj;
18850     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18851     int *arg2 = (int *) 0 ;
18852     int *arg3 = (int *) 0 ;
18853     int temp2 ;
18854     int res2 = 0 ;
18855     int temp3 ;
18856     int res3 = 0 ;
18857     PyObject * obj0 = 0 ;
18858     char *kwnames[] = {
18859         (char *) "self", NULL
18860     };
18861
18862     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18863     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetSize",kwnames,&obj0)) goto fail;
18865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18866     if (SWIG_arg_fail(1)) SWIG_fail;
18867     {
18868         PyThreadState* __tstate = wxPyBeginAllowThreads();
18869         ((wxPyPanel const *)arg1)->base_DoGetSize(arg2,arg3);
18870
18871         wxPyEndAllowThreads(__tstate);
18872         if (PyErr_Occurred()) SWIG_fail;
18873     }
18874     Py_INCREF(Py_None); resultobj = Py_None;
18875     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18876     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18877     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18878     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18879     return resultobj;
18880     fail:
18881     return NULL;
18882 }
18883
18884
18885 static PyObject *_wrap_PyPanel_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18886     PyObject *resultobj;
18887     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18888     int *arg2 = (int *) 0 ;
18889     int *arg3 = (int *) 0 ;
18890     int temp2 ;
18891     int res2 = 0 ;
18892     int temp3 ;
18893     int res3 = 0 ;
18894     PyObject * obj0 = 0 ;
18895     char *kwnames[] = {
18896         (char *) "self", NULL
18897     };
18898
18899     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18900     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18903     if (SWIG_arg_fail(1)) SWIG_fail;
18904     {
18905         PyThreadState* __tstate = wxPyBeginAllowThreads();
18906         ((wxPyPanel const *)arg1)->base_DoGetClientSize(arg2,arg3);
18907
18908         wxPyEndAllowThreads(__tstate);
18909         if (PyErr_Occurred()) SWIG_fail;
18910     }
18911     Py_INCREF(Py_None); resultobj = Py_None;
18912     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18913     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18914     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18915     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18916     return resultobj;
18917     fail:
18918     return NULL;
18919 }
18920
18921
18922 static PyObject *_wrap_PyPanel_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18923     PyObject *resultobj;
18924     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18925     int *arg2 = (int *) 0 ;
18926     int *arg3 = (int *) 0 ;
18927     int temp2 ;
18928     int res2 = 0 ;
18929     int temp3 ;
18930     int res3 = 0 ;
18931     PyObject * obj0 = 0 ;
18932     char *kwnames[] = {
18933         (char *) "self", NULL
18934     };
18935
18936     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18937     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18938     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetPosition",kwnames,&obj0)) goto fail;
18939     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18940     if (SWIG_arg_fail(1)) SWIG_fail;
18941     {
18942         PyThreadState* __tstate = wxPyBeginAllowThreads();
18943         ((wxPyPanel const *)arg1)->base_DoGetPosition(arg2,arg3);
18944
18945         wxPyEndAllowThreads(__tstate);
18946         if (PyErr_Occurred()) SWIG_fail;
18947     }
18948     Py_INCREF(Py_None); resultobj = Py_None;
18949     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18950     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18951     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18952     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18953     return resultobj;
18954     fail:
18955     return NULL;
18956 }
18957
18958
18959 static PyObject *_wrap_PyPanel_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18960     PyObject *resultobj;
18961     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18962     wxSize result;
18963     PyObject * obj0 = 0 ;
18964     char *kwnames[] = {
18965         (char *) "self", NULL
18966     };
18967
18968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18969     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18970     if (SWIG_arg_fail(1)) SWIG_fail;
18971     {
18972         PyThreadState* __tstate = wxPyBeginAllowThreads();
18973         result = ((wxPyPanel const *)arg1)->base_DoGetVirtualSize();
18974
18975         wxPyEndAllowThreads(__tstate);
18976         if (PyErr_Occurred()) SWIG_fail;
18977     }
18978     {
18979         wxSize * resultptr;
18980         resultptr = new wxSize((wxSize &)(result));
18981         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18982     }
18983     return resultobj;
18984     fail:
18985     return NULL;
18986 }
18987
18988
18989 static PyObject *_wrap_PyPanel_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18990     PyObject *resultobj;
18991     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18992     wxSize result;
18993     PyObject * obj0 = 0 ;
18994     char *kwnames[] = {
18995         (char *) "self", NULL
18996     };
18997
18998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19000     if (SWIG_arg_fail(1)) SWIG_fail;
19001     {
19002         PyThreadState* __tstate = wxPyBeginAllowThreads();
19003         result = ((wxPyPanel const *)arg1)->base_DoGetBestSize();
19004
19005         wxPyEndAllowThreads(__tstate);
19006         if (PyErr_Occurred()) SWIG_fail;
19007     }
19008     {
19009         wxSize * resultptr;
19010         resultptr = new wxSize((wxSize &)(result));
19011         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19012     }
19013     return resultobj;
19014     fail:
19015     return NULL;
19016 }
19017
19018
19019 static PyObject *_wrap_PyPanel_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19020     PyObject *resultobj;
19021     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19022     PyObject * obj0 = 0 ;
19023     char *kwnames[] = {
19024         (char *) "self", NULL
19025     };
19026
19027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_InitDialog",kwnames,&obj0)) goto fail;
19028     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19029     if (SWIG_arg_fail(1)) SWIG_fail;
19030     {
19031         PyThreadState* __tstate = wxPyBeginAllowThreads();
19032         (arg1)->base_InitDialog();
19033
19034         wxPyEndAllowThreads(__tstate);
19035         if (PyErr_Occurred()) SWIG_fail;
19036     }
19037     Py_INCREF(Py_None); resultobj = Py_None;
19038     return resultobj;
19039     fail:
19040     return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_PyPanel_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19045     PyObject *resultobj;
19046     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19047     bool result;
19048     PyObject * obj0 = 0 ;
19049     char *kwnames[] = {
19050         (char *) "self", NULL
19051     };
19052
19053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19054     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19055     if (SWIG_arg_fail(1)) SWIG_fail;
19056     {
19057         PyThreadState* __tstate = wxPyBeginAllowThreads();
19058         result = (bool)(arg1)->base_TransferDataToWindow();
19059
19060         wxPyEndAllowThreads(__tstate);
19061         if (PyErr_Occurred()) SWIG_fail;
19062     }
19063     {
19064         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19065     }
19066     return resultobj;
19067     fail:
19068     return NULL;
19069 }
19070
19071
19072 static PyObject *_wrap_PyPanel_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19073     PyObject *resultobj;
19074     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19075     bool result;
19076     PyObject * obj0 = 0 ;
19077     char *kwnames[] = {
19078         (char *) "self", NULL
19079     };
19080
19081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19083     if (SWIG_arg_fail(1)) SWIG_fail;
19084     {
19085         PyThreadState* __tstate = wxPyBeginAllowThreads();
19086         result = (bool)(arg1)->base_TransferDataFromWindow();
19087
19088         wxPyEndAllowThreads(__tstate);
19089         if (PyErr_Occurred()) SWIG_fail;
19090     }
19091     {
19092         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19093     }
19094     return resultobj;
19095     fail:
19096     return NULL;
19097 }
19098
19099
19100 static PyObject *_wrap_PyPanel_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19101     PyObject *resultobj;
19102     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19103     bool result;
19104     PyObject * obj0 = 0 ;
19105     char *kwnames[] = {
19106         (char *) "self", NULL
19107     };
19108
19109     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_Validate",kwnames,&obj0)) goto fail;
19110     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19111     if (SWIG_arg_fail(1)) SWIG_fail;
19112     {
19113         PyThreadState* __tstate = wxPyBeginAllowThreads();
19114         result = (bool)(arg1)->base_Validate();
19115
19116         wxPyEndAllowThreads(__tstate);
19117         if (PyErr_Occurred()) SWIG_fail;
19118     }
19119     {
19120         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19121     }
19122     return resultobj;
19123     fail:
19124     return NULL;
19125 }
19126
19127
19128 static PyObject *_wrap_PyPanel_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19129     PyObject *resultobj;
19130     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19131     bool result;
19132     PyObject * obj0 = 0 ;
19133     char *kwnames[] = {
19134         (char *) "self", NULL
19135     };
19136
19137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19138     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19139     if (SWIG_arg_fail(1)) SWIG_fail;
19140     {
19141         PyThreadState* __tstate = wxPyBeginAllowThreads();
19142         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocus();
19143
19144         wxPyEndAllowThreads(__tstate);
19145         if (PyErr_Occurred()) SWIG_fail;
19146     }
19147     {
19148         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19149     }
19150     return resultobj;
19151     fail:
19152     return NULL;
19153 }
19154
19155
19156 static PyObject *_wrap_PyPanel_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
19157     PyObject *resultobj;
19158     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19159     bool result;
19160     PyObject * obj0 = 0 ;
19161     char *kwnames[] = {
19162         (char *) "self", NULL
19163     };
19164
19165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
19166     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19167     if (SWIG_arg_fail(1)) SWIG_fail;
19168     {
19169         PyThreadState* __tstate = wxPyBeginAllowThreads();
19170         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocusFromKeyboard();
19171
19172         wxPyEndAllowThreads(__tstate);
19173         if (PyErr_Occurred()) SWIG_fail;
19174     }
19175     {
19176         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19177     }
19178     return resultobj;
19179     fail:
19180     return NULL;
19181 }
19182
19183
19184 static PyObject *_wrap_PyPanel_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
19185     PyObject *resultobj;
19186     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19187     wxSize result;
19188     PyObject * obj0 = 0 ;
19189     char *kwnames[] = {
19190         (char *) "self", NULL
19191     };
19192
19193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetMaxSize",kwnames,&obj0)) goto fail;
19194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19195     if (SWIG_arg_fail(1)) SWIG_fail;
19196     {
19197         PyThreadState* __tstate = wxPyBeginAllowThreads();
19198         result = ((wxPyPanel const *)arg1)->base_GetMaxSize();
19199
19200         wxPyEndAllowThreads(__tstate);
19201         if (PyErr_Occurred()) SWIG_fail;
19202     }
19203     {
19204         wxSize * resultptr;
19205         resultptr = new wxSize((wxSize &)(result));
19206         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19207     }
19208     return resultobj;
19209     fail:
19210     return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_PyPanel_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
19215     PyObject *resultobj;
19216     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19217     wxWindow *arg2 = (wxWindow *) 0 ;
19218     PyObject * obj0 = 0 ;
19219     PyObject * obj1 = 0 ;
19220     char *kwnames[] = {
19221         (char *) "self",(char *) "child", NULL
19222     };
19223
19224     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
19225     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19226     if (SWIG_arg_fail(1)) SWIG_fail;
19227     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19228     if (SWIG_arg_fail(2)) SWIG_fail;
19229     {
19230         PyThreadState* __tstate = wxPyBeginAllowThreads();
19231         (arg1)->base_AddChild(arg2);
19232
19233         wxPyEndAllowThreads(__tstate);
19234         if (PyErr_Occurred()) SWIG_fail;
19235     }
19236     Py_INCREF(Py_None); resultobj = Py_None;
19237     return resultobj;
19238     fail:
19239     return NULL;
19240 }
19241
19242
19243 static PyObject *_wrap_PyPanel_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
19244     PyObject *resultobj;
19245     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19246     wxWindow *arg2 = (wxWindow *) 0 ;
19247     PyObject * obj0 = 0 ;
19248     PyObject * obj1 = 0 ;
19249     char *kwnames[] = {
19250         (char *) "self",(char *) "child", NULL
19251     };
19252
19253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
19254     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19255     if (SWIG_arg_fail(1)) SWIG_fail;
19256     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19257     if (SWIG_arg_fail(2)) SWIG_fail;
19258     {
19259         PyThreadState* __tstate = wxPyBeginAllowThreads();
19260         (arg1)->base_RemoveChild(arg2);
19261
19262         wxPyEndAllowThreads(__tstate);
19263         if (PyErr_Occurred()) SWIG_fail;
19264     }
19265     Py_INCREF(Py_None); resultobj = Py_None;
19266     return resultobj;
19267     fail:
19268     return NULL;
19269 }
19270
19271
19272 static PyObject *_wrap_PyPanel_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
19273     PyObject *resultobj;
19274     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19275     bool result;
19276     PyObject * obj0 = 0 ;
19277     char *kwnames[] = {
19278         (char *) "self", NULL
19279     };
19280
19281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
19282     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19283     if (SWIG_arg_fail(1)) SWIG_fail;
19284     {
19285         PyThreadState* __tstate = wxPyBeginAllowThreads();
19286         result = (bool)((wxPyPanel const *)arg1)->base_ShouldInheritColours();
19287
19288         wxPyEndAllowThreads(__tstate);
19289         if (PyErr_Occurred()) SWIG_fail;
19290     }
19291     {
19292         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19293     }
19294     return resultobj;
19295     fail:
19296     return NULL;
19297 }
19298
19299
19300 static PyObject *_wrap_PyPanel_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
19301     PyObject *resultobj;
19302     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19303     wxColour *arg2 = 0 ;
19304     wxColour temp2 ;
19305     PyObject * obj0 = 0 ;
19306     PyObject * obj1 = 0 ;
19307     char *kwnames[] = {
19308         (char *) "self",(char *) "c", NULL
19309     };
19310
19311     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
19312     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19313     if (SWIG_arg_fail(1)) SWIG_fail;
19314     {
19315         arg2 = &temp2;
19316         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19317     }
19318     {
19319         PyThreadState* __tstate = wxPyBeginAllowThreads();
19320         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
19321
19322         wxPyEndAllowThreads(__tstate);
19323         if (PyErr_Occurred()) SWIG_fail;
19324     }
19325     Py_INCREF(Py_None); resultobj = Py_None;
19326     return resultobj;
19327     fail:
19328     return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_PyPanel_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
19333     PyObject *resultobj;
19334     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19335     wxVisualAttributes result;
19336     PyObject * obj0 = 0 ;
19337     char *kwnames[] = {
19338         (char *) "self", NULL
19339     };
19340
19341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
19347
19348         wxPyEndAllowThreads(__tstate);
19349         if (PyErr_Occurred()) SWIG_fail;
19350     }
19351     {
19352         wxVisualAttributes * resultptr;
19353         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
19354         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
19355     }
19356     return resultobj;
19357     fail:
19358     return NULL;
19359 }
19360
19361
19362 static PyObject * PyPanel_swigregister(PyObject *, PyObject *args) {
19363     PyObject *obj;
19364     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19365     SWIG_TypeClientData(SWIGTYPE_p_wxPyPanel, obj);
19366     Py_INCREF(obj);
19367     return Py_BuildValue((char *)"");
19368 }
19369 static PyObject *_wrap_new_PyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19370     PyObject *resultobj;
19371     wxWindow *arg1 = (wxWindow *) 0 ;
19372     int arg2 = (int) (int)-1 ;
19373     wxPoint const &arg3_defvalue = wxDefaultPosition ;
19374     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
19375     wxSize const &arg4_defvalue = wxDefaultSize ;
19376     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
19377     long arg5 = (long) 0 ;
19378     wxString const &arg6_defvalue = wxPyPanelNameStr ;
19379     wxString *arg6 = (wxString *) &arg6_defvalue ;
19380     wxPyScrolledWindow *result;
19381     wxPoint temp3 ;
19382     wxSize temp4 ;
19383     bool temp6 = false ;
19384     PyObject * obj0 = 0 ;
19385     PyObject * obj1 = 0 ;
19386     PyObject * obj2 = 0 ;
19387     PyObject * obj3 = 0 ;
19388     PyObject * obj4 = 0 ;
19389     PyObject * obj5 = 0 ;
19390     char *kwnames[] = {
19391         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
19392     };
19393
19394     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19395     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19396     if (SWIG_arg_fail(1)) SWIG_fail;
19397     if (obj1) {
19398         {
19399             arg2 = (int const)(SWIG_As_int(obj1));
19400             if (SWIG_arg_fail(2)) SWIG_fail;
19401         }
19402     }
19403     if (obj2) {
19404         {
19405             arg3 = &temp3;
19406             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19407         }
19408     }
19409     if (obj3) {
19410         {
19411             arg4 = &temp4;
19412             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
19413         }
19414     }
19415     if (obj4) {
19416         {
19417             arg5 = (long)(SWIG_As_long(obj4));
19418             if (SWIG_arg_fail(5)) SWIG_fail;
19419         }
19420     }
19421     if (obj5) {
19422         {
19423             arg6 = wxString_in_helper(obj5);
19424             if (arg6 == NULL) SWIG_fail;
19425             temp6 = true;
19426         }
19427     }
19428     {
19429         if (!wxPyCheckForApp()) SWIG_fail;
19430         PyThreadState* __tstate = wxPyBeginAllowThreads();
19431         result = (wxPyScrolledWindow *)new wxPyScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
19432
19433         wxPyEndAllowThreads(__tstate);
19434         if (PyErr_Occurred()) SWIG_fail;
19435     }
19436     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19437     {
19438         if (temp6)
19439         delete arg6;
19440     }
19441     return resultobj;
19442     fail:
19443     {
19444         if (temp6)
19445         delete arg6;
19446     }
19447     return NULL;
19448 }
19449
19450
19451 static PyObject *_wrap_new_PrePyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19452     PyObject *resultobj;
19453     wxPyScrolledWindow *result;
19454     char *kwnames[] = {
19455         NULL
19456     };
19457
19458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyScrolledWindow",kwnames)) goto fail;
19459     {
19460         if (!wxPyCheckForApp()) SWIG_fail;
19461         PyThreadState* __tstate = wxPyBeginAllowThreads();
19462         result = (wxPyScrolledWindow *)new wxPyScrolledWindow();
19463
19464         wxPyEndAllowThreads(__tstate);
19465         if (PyErr_Occurred()) SWIG_fail;
19466     }
19467     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19468     return resultobj;
19469     fail:
19470     return NULL;
19471 }
19472
19473
19474 static PyObject *_wrap_PyScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
19475     PyObject *resultobj;
19476     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19477     PyObject *arg2 = (PyObject *) 0 ;
19478     PyObject *arg3 = (PyObject *) 0 ;
19479     PyObject * obj0 = 0 ;
19480     PyObject * obj1 = 0 ;
19481     PyObject * obj2 = 0 ;
19482     char *kwnames[] = {
19483         (char *) "self",(char *) "self",(char *) "_class", NULL
19484     };
19485
19486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
19487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19488     if (SWIG_arg_fail(1)) SWIG_fail;
19489     arg2 = obj1;
19490     arg3 = obj2;
19491     {
19492         PyThreadState* __tstate = wxPyBeginAllowThreads();
19493         (arg1)->_setCallbackInfo(arg2,arg3);
19494
19495         wxPyEndAllowThreads(__tstate);
19496         if (PyErr_Occurred()) SWIG_fail;
19497     }
19498     Py_INCREF(Py_None); resultobj = Py_None;
19499     return resultobj;
19500     fail:
19501     return NULL;
19502 }
19503
19504
19505 static PyObject *_wrap_PyScrolledWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19506     PyObject *resultobj;
19507     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19508     wxSize *arg2 = 0 ;
19509     wxSize temp2 ;
19510     PyObject * obj0 = 0 ;
19511     PyObject * obj1 = 0 ;
19512     char *kwnames[] = {
19513         (char *) "self",(char *) "size", NULL
19514     };
19515
19516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
19517     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19518     if (SWIG_arg_fail(1)) SWIG_fail;
19519     {
19520         arg2 = &temp2;
19521         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
19522     }
19523     {
19524         PyThreadState* __tstate = wxPyBeginAllowThreads();
19525         (arg1)->SetBestSize((wxSize const &)*arg2);
19526
19527         wxPyEndAllowThreads(__tstate);
19528         if (PyErr_Occurred()) SWIG_fail;
19529     }
19530     Py_INCREF(Py_None); resultobj = Py_None;
19531     return resultobj;
19532     fail:
19533     return NULL;
19534 }
19535
19536
19537 static PyObject *_wrap_PyScrolledWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19538     PyObject *resultobj;
19539     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19540     int arg2 ;
19541     int arg3 ;
19542     int arg4 ;
19543     int arg5 ;
19544     PyObject * obj0 = 0 ;
19545     PyObject * obj1 = 0 ;
19546     PyObject * obj2 = 0 ;
19547     PyObject * obj3 = 0 ;
19548     PyObject * obj4 = 0 ;
19549     char *kwnames[] = {
19550         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19551     };
19552
19553     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyScrolledWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19554     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19555     if (SWIG_arg_fail(1)) SWIG_fail;
19556     {
19557         arg2 = (int)(SWIG_As_int(obj1));
19558         if (SWIG_arg_fail(2)) SWIG_fail;
19559     }
19560     {
19561         arg3 = (int)(SWIG_As_int(obj2));
19562         if (SWIG_arg_fail(3)) SWIG_fail;
19563     }
19564     {
19565         arg4 = (int)(SWIG_As_int(obj3));
19566         if (SWIG_arg_fail(4)) SWIG_fail;
19567     }
19568     {
19569         arg5 = (int)(SWIG_As_int(obj4));
19570         if (SWIG_arg_fail(5)) SWIG_fail;
19571     }
19572     {
19573         PyThreadState* __tstate = wxPyBeginAllowThreads();
19574         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
19575
19576         wxPyEndAllowThreads(__tstate);
19577         if (PyErr_Occurred()) SWIG_fail;
19578     }
19579     Py_INCREF(Py_None); resultobj = Py_None;
19580     return resultobj;
19581     fail:
19582     return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_PyScrolledWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19587     PyObject *resultobj;
19588     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19589     int arg2 ;
19590     int arg3 ;
19591     int arg4 ;
19592     int arg5 ;
19593     int arg6 = (int) wxSIZE_AUTO ;
19594     PyObject * obj0 = 0 ;
19595     PyObject * obj1 = 0 ;
19596     PyObject * obj2 = 0 ;
19597     PyObject * obj3 = 0 ;
19598     PyObject * obj4 = 0 ;
19599     PyObject * obj5 = 0 ;
19600     char *kwnames[] = {
19601         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
19602     };
19603
19604     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyScrolledWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19605     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19606     if (SWIG_arg_fail(1)) SWIG_fail;
19607     {
19608         arg2 = (int)(SWIG_As_int(obj1));
19609         if (SWIG_arg_fail(2)) SWIG_fail;
19610     }
19611     {
19612         arg3 = (int)(SWIG_As_int(obj2));
19613         if (SWIG_arg_fail(3)) SWIG_fail;
19614     }
19615     {
19616         arg4 = (int)(SWIG_As_int(obj3));
19617         if (SWIG_arg_fail(4)) SWIG_fail;
19618     }
19619     {
19620         arg5 = (int)(SWIG_As_int(obj4));
19621         if (SWIG_arg_fail(5)) SWIG_fail;
19622     }
19623     if (obj5) {
19624         {
19625             arg6 = (int)(SWIG_As_int(obj5));
19626             if (SWIG_arg_fail(6)) SWIG_fail;
19627         }
19628     }
19629     {
19630         PyThreadState* __tstate = wxPyBeginAllowThreads();
19631         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
19632
19633         wxPyEndAllowThreads(__tstate);
19634         if (PyErr_Occurred()) SWIG_fail;
19635     }
19636     Py_INCREF(Py_None); resultobj = Py_None;
19637     return resultobj;
19638     fail:
19639     return NULL;
19640 }
19641
19642
19643 static PyObject *_wrap_PyScrolledWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19644     PyObject *resultobj;
19645     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19646     int arg2 ;
19647     int arg3 ;
19648     PyObject * obj0 = 0 ;
19649     PyObject * obj1 = 0 ;
19650     PyObject * obj2 = 0 ;
19651     char *kwnames[] = {
19652         (char *) "self",(char *) "width",(char *) "height", NULL
19653     };
19654
19655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19657     if (SWIG_arg_fail(1)) SWIG_fail;
19658     {
19659         arg2 = (int)(SWIG_As_int(obj1));
19660         if (SWIG_arg_fail(2)) SWIG_fail;
19661     }
19662     {
19663         arg3 = (int)(SWIG_As_int(obj2));
19664         if (SWIG_arg_fail(3)) SWIG_fail;
19665     }
19666     {
19667         PyThreadState* __tstate = wxPyBeginAllowThreads();
19668         (arg1)->base_DoSetClientSize(arg2,arg3);
19669
19670         wxPyEndAllowThreads(__tstate);
19671         if (PyErr_Occurred()) SWIG_fail;
19672     }
19673     Py_INCREF(Py_None); resultobj = Py_None;
19674     return resultobj;
19675     fail:
19676     return NULL;
19677 }
19678
19679
19680 static PyObject *_wrap_PyScrolledWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19681     PyObject *resultobj;
19682     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19683     int arg2 ;
19684     int arg3 ;
19685     PyObject * obj0 = 0 ;
19686     PyObject * obj1 = 0 ;
19687     PyObject * obj2 = 0 ;
19688     char *kwnames[] = {
19689         (char *) "self",(char *) "x",(char *) "y", NULL
19690     };
19691
19692     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19693     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19694     if (SWIG_arg_fail(1)) SWIG_fail;
19695     {
19696         arg2 = (int)(SWIG_As_int(obj1));
19697         if (SWIG_arg_fail(2)) SWIG_fail;
19698     }
19699     {
19700         arg3 = (int)(SWIG_As_int(obj2));
19701         if (SWIG_arg_fail(3)) SWIG_fail;
19702     }
19703     {
19704         PyThreadState* __tstate = wxPyBeginAllowThreads();
19705         (arg1)->base_DoSetVirtualSize(arg2,arg3);
19706
19707         wxPyEndAllowThreads(__tstate);
19708         if (PyErr_Occurred()) SWIG_fail;
19709     }
19710     Py_INCREF(Py_None); resultobj = Py_None;
19711     return resultobj;
19712     fail:
19713     return NULL;
19714 }
19715
19716
19717 static PyObject *_wrap_PyScrolledWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19718     PyObject *resultobj;
19719     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19720     int *arg2 = (int *) 0 ;
19721     int *arg3 = (int *) 0 ;
19722     int temp2 ;
19723     int res2 = 0 ;
19724     int temp3 ;
19725     int res3 = 0 ;
19726     PyObject * obj0 = 0 ;
19727     char *kwnames[] = {
19728         (char *) "self", NULL
19729     };
19730
19731     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19732     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
19734     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19735     if (SWIG_arg_fail(1)) SWIG_fail;
19736     {
19737         PyThreadState* __tstate = wxPyBeginAllowThreads();
19738         ((wxPyScrolledWindow const *)arg1)->base_DoGetSize(arg2,arg3);
19739
19740         wxPyEndAllowThreads(__tstate);
19741         if (PyErr_Occurred()) SWIG_fail;
19742     }
19743     Py_INCREF(Py_None); resultobj = Py_None;
19744     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19745     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19746     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19747     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19748     return resultobj;
19749     fail:
19750     return NULL;
19751 }
19752
19753
19754 static PyObject *_wrap_PyScrolledWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19755     PyObject *resultobj;
19756     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19757     int *arg2 = (int *) 0 ;
19758     int *arg3 = (int *) 0 ;
19759     int temp2 ;
19760     int res2 = 0 ;
19761     int temp3 ;
19762     int res3 = 0 ;
19763     PyObject * obj0 = 0 ;
19764     char *kwnames[] = {
19765         (char *) "self", NULL
19766     };
19767
19768     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19769     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19771     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19772     if (SWIG_arg_fail(1)) SWIG_fail;
19773     {
19774         PyThreadState* __tstate = wxPyBeginAllowThreads();
19775         ((wxPyScrolledWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
19776
19777         wxPyEndAllowThreads(__tstate);
19778         if (PyErr_Occurred()) SWIG_fail;
19779     }
19780     Py_INCREF(Py_None); resultobj = Py_None;
19781     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19782     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19783     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19784     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19785     return resultobj;
19786     fail:
19787     return NULL;
19788 }
19789
19790
19791 static PyObject *_wrap_PyScrolledWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19792     PyObject *resultobj;
19793     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19794     int *arg2 = (int *) 0 ;
19795     int *arg3 = (int *) 0 ;
19796     int temp2 ;
19797     int res2 = 0 ;
19798     int temp3 ;
19799     int res3 = 0 ;
19800     PyObject * obj0 = 0 ;
19801     char *kwnames[] = {
19802         (char *) "self", NULL
19803     };
19804
19805     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19806     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
19808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19809     if (SWIG_arg_fail(1)) SWIG_fail;
19810     {
19811         PyThreadState* __tstate = wxPyBeginAllowThreads();
19812         ((wxPyScrolledWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
19813
19814         wxPyEndAllowThreads(__tstate);
19815         if (PyErr_Occurred()) SWIG_fail;
19816     }
19817     Py_INCREF(Py_None); resultobj = Py_None;
19818     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19819     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19820     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19821     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19822     return resultobj;
19823     fail:
19824     return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_PyScrolledWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19829     PyObject *resultobj;
19830     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19831     wxSize result;
19832     PyObject * obj0 = 0 ;
19833     char *kwnames[] = {
19834         (char *) "self", NULL
19835     };
19836
19837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19839     if (SWIG_arg_fail(1)) SWIG_fail;
19840     {
19841         PyThreadState* __tstate = wxPyBeginAllowThreads();
19842         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetVirtualSize();
19843
19844         wxPyEndAllowThreads(__tstate);
19845         if (PyErr_Occurred()) SWIG_fail;
19846     }
19847     {
19848         wxSize * resultptr;
19849         resultptr = new wxSize((wxSize &)(result));
19850         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19851     }
19852     return resultobj;
19853     fail:
19854     return NULL;
19855 }
19856
19857
19858 static PyObject *_wrap_PyScrolledWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19859     PyObject *resultobj;
19860     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19861     wxSize result;
19862     PyObject * obj0 = 0 ;
19863     char *kwnames[] = {
19864         (char *) "self", NULL
19865     };
19866
19867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
19868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19869     if (SWIG_arg_fail(1)) SWIG_fail;
19870     {
19871         PyThreadState* __tstate = wxPyBeginAllowThreads();
19872         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetBestSize();
19873
19874         wxPyEndAllowThreads(__tstate);
19875         if (PyErr_Occurred()) SWIG_fail;
19876     }
19877     {
19878         wxSize * resultptr;
19879         resultptr = new wxSize((wxSize &)(result));
19880         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19881     }
19882     return resultobj;
19883     fail:
19884     return NULL;
19885 }
19886
19887
19888 static PyObject *_wrap_PyScrolledWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19889     PyObject *resultobj;
19890     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19891     PyObject * obj0 = 0 ;
19892     char *kwnames[] = {
19893         (char *) "self", NULL
19894     };
19895
19896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_InitDialog",kwnames,&obj0)) goto fail;
19897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19898     if (SWIG_arg_fail(1)) SWIG_fail;
19899     {
19900         PyThreadState* __tstate = wxPyBeginAllowThreads();
19901         (arg1)->base_InitDialog();
19902
19903         wxPyEndAllowThreads(__tstate);
19904         if (PyErr_Occurred()) SWIG_fail;
19905     }
19906     Py_INCREF(Py_None); resultobj = Py_None;
19907     return resultobj;
19908     fail:
19909     return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_PyScrolledWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19914     PyObject *resultobj;
19915     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19916     bool result;
19917     PyObject * obj0 = 0 ;
19918     char *kwnames[] = {
19919         (char *) "self", NULL
19920     };
19921
19922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19923     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19924     if (SWIG_arg_fail(1)) SWIG_fail;
19925     {
19926         PyThreadState* __tstate = wxPyBeginAllowThreads();
19927         result = (bool)(arg1)->base_TransferDataToWindow();
19928
19929         wxPyEndAllowThreads(__tstate);
19930         if (PyErr_Occurred()) SWIG_fail;
19931     }
19932     {
19933         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19934     }
19935     return resultobj;
19936     fail:
19937     return NULL;
19938 }
19939
19940
19941 static PyObject *_wrap_PyScrolledWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19942     PyObject *resultobj;
19943     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19944     bool result;
19945     PyObject * obj0 = 0 ;
19946     char *kwnames[] = {
19947         (char *) "self", NULL
19948     };
19949
19950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19952     if (SWIG_arg_fail(1)) SWIG_fail;
19953     {
19954         PyThreadState* __tstate = wxPyBeginAllowThreads();
19955         result = (bool)(arg1)->base_TransferDataFromWindow();
19956
19957         wxPyEndAllowThreads(__tstate);
19958         if (PyErr_Occurred()) SWIG_fail;
19959     }
19960     {
19961         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19962     }
19963     return resultobj;
19964     fail:
19965     return NULL;
19966 }
19967
19968
19969 static PyObject *_wrap_PyScrolledWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19970     PyObject *resultobj;
19971     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19972     bool result;
19973     PyObject * obj0 = 0 ;
19974     char *kwnames[] = {
19975         (char *) "self", NULL
19976     };
19977
19978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_Validate",kwnames,&obj0)) goto fail;
19979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19980     if (SWIG_arg_fail(1)) SWIG_fail;
19981     {
19982         PyThreadState* __tstate = wxPyBeginAllowThreads();
19983         result = (bool)(arg1)->base_Validate();
19984
19985         wxPyEndAllowThreads(__tstate);
19986         if (PyErr_Occurred()) SWIG_fail;
19987     }
19988     {
19989         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19990     }
19991     return resultobj;
19992     fail:
19993     return NULL;
19994 }
19995
19996
19997 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19998     PyObject *resultobj;
19999     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20000     bool result;
20001     PyObject * obj0 = 0 ;
20002     char *kwnames[] = {
20003         (char *) "self", NULL
20004     };
20005
20006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
20007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20008     if (SWIG_arg_fail(1)) SWIG_fail;
20009     {
20010         PyThreadState* __tstate = wxPyBeginAllowThreads();
20011         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocus();
20012
20013         wxPyEndAllowThreads(__tstate);
20014         if (PyErr_Occurred()) SWIG_fail;
20015     }
20016     {
20017         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20018     }
20019     return resultobj;
20020     fail:
20021     return NULL;
20022 }
20023
20024
20025 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
20026     PyObject *resultobj;
20027     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20028     bool result;
20029     PyObject * obj0 = 0 ;
20030     char *kwnames[] = {
20031         (char *) "self", NULL
20032     };
20033
20034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
20035     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20036     if (SWIG_arg_fail(1)) SWIG_fail;
20037     {
20038         PyThreadState* __tstate = wxPyBeginAllowThreads();
20039         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
20040
20041         wxPyEndAllowThreads(__tstate);
20042         if (PyErr_Occurred()) SWIG_fail;
20043     }
20044     {
20045         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20046     }
20047     return resultobj;
20048     fail:
20049     return NULL;
20050 }
20051
20052
20053 static PyObject *_wrap_PyScrolledWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
20054     PyObject *resultobj;
20055     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20056     wxSize result;
20057     PyObject * obj0 = 0 ;
20058     char *kwnames[] = {
20059         (char *) "self", NULL
20060     };
20061
20062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
20063     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20064     if (SWIG_arg_fail(1)) SWIG_fail;
20065     {
20066         PyThreadState* __tstate = wxPyBeginAllowThreads();
20067         result = ((wxPyScrolledWindow const *)arg1)->base_GetMaxSize();
20068
20069         wxPyEndAllowThreads(__tstate);
20070         if (PyErr_Occurred()) SWIG_fail;
20071     }
20072     {
20073         wxSize * resultptr;
20074         resultptr = new wxSize((wxSize &)(result));
20075         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20076     }
20077     return resultobj;
20078     fail:
20079     return NULL;
20080 }
20081
20082
20083 static PyObject *_wrap_PyScrolledWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
20084     PyObject *resultobj;
20085     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20086     wxWindow *arg2 = (wxWindow *) 0 ;
20087     PyObject * obj0 = 0 ;
20088     PyObject * obj1 = 0 ;
20089     char *kwnames[] = {
20090         (char *) "self",(char *) "child", NULL
20091     };
20092
20093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
20094     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20095     if (SWIG_arg_fail(1)) SWIG_fail;
20096     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20097     if (SWIG_arg_fail(2)) SWIG_fail;
20098     {
20099         PyThreadState* __tstate = wxPyBeginAllowThreads();
20100         (arg1)->base_AddChild(arg2);
20101
20102         wxPyEndAllowThreads(__tstate);
20103         if (PyErr_Occurred()) SWIG_fail;
20104     }
20105     Py_INCREF(Py_None); resultobj = Py_None;
20106     return resultobj;
20107     fail:
20108     return NULL;
20109 }
20110
20111
20112 static PyObject *_wrap_PyScrolledWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
20113     PyObject *resultobj;
20114     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20115     wxWindow *arg2 = (wxWindow *) 0 ;
20116     PyObject * obj0 = 0 ;
20117     PyObject * obj1 = 0 ;
20118     char *kwnames[] = {
20119         (char *) "self",(char *) "child", NULL
20120     };
20121
20122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
20123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20124     if (SWIG_arg_fail(1)) SWIG_fail;
20125     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20126     if (SWIG_arg_fail(2)) SWIG_fail;
20127     {
20128         PyThreadState* __tstate = wxPyBeginAllowThreads();
20129         (arg1)->base_RemoveChild(arg2);
20130
20131         wxPyEndAllowThreads(__tstate);
20132         if (PyErr_Occurred()) SWIG_fail;
20133     }
20134     Py_INCREF(Py_None); resultobj = Py_None;
20135     return resultobj;
20136     fail:
20137     return NULL;
20138 }
20139
20140
20141 static PyObject *_wrap_PyScrolledWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
20142     PyObject *resultobj;
20143     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20144     bool result;
20145     PyObject * obj0 = 0 ;
20146     char *kwnames[] = {
20147         (char *) "self", NULL
20148     };
20149
20150     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
20151     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20152     if (SWIG_arg_fail(1)) SWIG_fail;
20153     {
20154         PyThreadState* __tstate = wxPyBeginAllowThreads();
20155         result = (bool)((wxPyScrolledWindow const *)arg1)->base_ShouldInheritColours();
20156
20157         wxPyEndAllowThreads(__tstate);
20158         if (PyErr_Occurred()) SWIG_fail;
20159     }
20160     {
20161         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20162     }
20163     return resultobj;
20164     fail:
20165     return NULL;
20166 }
20167
20168
20169 static PyObject *_wrap_PyScrolledWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
20170     PyObject *resultobj;
20171     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20172     wxColour *arg2 = 0 ;
20173     wxColour temp2 ;
20174     PyObject * obj0 = 0 ;
20175     PyObject * obj1 = 0 ;
20176     char *kwnames[] = {
20177         (char *) "self",(char *) "c", NULL
20178     };
20179
20180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
20181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20182     if (SWIG_arg_fail(1)) SWIG_fail;
20183     {
20184         arg2 = &temp2;
20185         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20186     }
20187     {
20188         PyThreadState* __tstate = wxPyBeginAllowThreads();
20189         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
20190
20191         wxPyEndAllowThreads(__tstate);
20192         if (PyErr_Occurred()) SWIG_fail;
20193     }
20194     Py_INCREF(Py_None); resultobj = Py_None;
20195     return resultobj;
20196     fail:
20197     return NULL;
20198 }
20199
20200
20201 static PyObject *_wrap_PyScrolledWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
20202     PyObject *resultobj;
20203     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20204     wxVisualAttributes result;
20205     PyObject * obj0 = 0 ;
20206     char *kwnames[] = {
20207         (char *) "self", NULL
20208     };
20209
20210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
20216
20217         wxPyEndAllowThreads(__tstate);
20218         if (PyErr_Occurred()) SWIG_fail;
20219     }
20220     {
20221         wxVisualAttributes * resultptr;
20222         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
20223         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
20224     }
20225     return resultobj;
20226     fail:
20227     return NULL;
20228 }
20229
20230
20231 static PyObject * PyScrolledWindow_swigregister(PyObject *, PyObject *args) {
20232     PyObject *obj;
20233     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20234     SWIG_TypeClientData(SWIGTYPE_p_wxPyScrolledWindow, obj);
20235     Py_INCREF(obj);
20236     return Py_BuildValue((char *)"");
20237 }
20238 static int _wrap_PrintoutTitleStr_set(PyObject *) {
20239     PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
20240     return 1;
20241 }
20242
20243
20244 static PyObject *_wrap_PrintoutTitleStr_get(void) {
20245     PyObject *pyobj;
20246
20247     {
20248 #if wxUSE_UNICODE
20249         pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20250 #else
20251         pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20252 #endif
20253     }
20254     return pyobj;
20255 }
20256
20257
20258 static int _wrap_PreviewCanvasNameStr_set(PyObject *) {
20259     PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
20260     return 1;
20261 }
20262
20263
20264 static PyObject *_wrap_PreviewCanvasNameStr_get(void) {
20265     PyObject *pyobj;
20266
20267     {
20268 #if wxUSE_UNICODE
20269         pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20270 #else
20271         pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20272 #endif
20273     }
20274     return pyobj;
20275 }
20276
20277
20278 static PyObject *_wrap_new_PrintData__SWIG_0(PyObject *, PyObject *args) {
20279     PyObject *resultobj;
20280     wxPrintData *result;
20281
20282     if(!PyArg_ParseTuple(args,(char *)":new_PrintData")) goto fail;
20283     {
20284         PyThreadState* __tstate = wxPyBeginAllowThreads();
20285         result = (wxPrintData *)new wxPrintData();
20286
20287         wxPyEndAllowThreads(__tstate);
20288         if (PyErr_Occurred()) SWIG_fail;
20289     }
20290     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20291     return resultobj;
20292     fail:
20293     return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_new_PrintData__SWIG_1(PyObject *, PyObject *args) {
20298     PyObject *resultobj;
20299     wxPrintData *arg1 = 0 ;
20300     wxPrintData *result;
20301     PyObject * obj0 = 0 ;
20302
20303     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintData",&obj0)) goto fail;
20304     {
20305         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20306         if (SWIG_arg_fail(1)) SWIG_fail;
20307         if (arg1 == NULL) {
20308             SWIG_null_ref("wxPrintData");
20309         }
20310         if (SWIG_arg_fail(1)) SWIG_fail;
20311     }
20312     {
20313         PyThreadState* __tstate = wxPyBeginAllowThreads();
20314         result = (wxPrintData *)new wxPrintData((wxPrintData const &)*arg1);
20315
20316         wxPyEndAllowThreads(__tstate);
20317         if (PyErr_Occurred()) SWIG_fail;
20318     }
20319     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20320     return resultobj;
20321     fail:
20322     return NULL;
20323 }
20324
20325
20326 static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args) {
20327     int argc;
20328     PyObject *argv[2];
20329     int ii;
20330
20331     argc = PyObject_Length(args);
20332     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
20333         argv[ii] = PyTuple_GetItem(args,ii);
20334     }
20335     if (argc == 0) {
20336         return _wrap_new_PrintData__SWIG_0(self,args);
20337     }
20338     if (argc == 1) {
20339         int _v;
20340         {
20341             void *ptr = 0;
20342             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
20343                 _v = 0;
20344                 PyErr_Clear();
20345             } else {
20346                 _v = (ptr != 0);
20347             }
20348         }
20349         if (_v) {
20350             return _wrap_new_PrintData__SWIG_1(self,args);
20351         }
20352     }
20353
20354     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintData'");
20355     return NULL;
20356 }
20357
20358
20359 static PyObject *_wrap_delete_PrintData(PyObject *, PyObject *args, PyObject *kwargs) {
20360     PyObject *resultobj;
20361     wxPrintData *arg1 = (wxPrintData *) 0 ;
20362     PyObject * obj0 = 0 ;
20363     char *kwnames[] = {
20364         (char *) "self", NULL
20365     };
20366
20367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintData",kwnames,&obj0)) goto fail;
20368     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20369     if (SWIG_arg_fail(1)) SWIG_fail;
20370     {
20371         PyThreadState* __tstate = wxPyBeginAllowThreads();
20372         delete arg1;
20373
20374         wxPyEndAllowThreads(__tstate);
20375         if (PyErr_Occurred()) SWIG_fail;
20376     }
20377     Py_INCREF(Py_None); resultobj = Py_None;
20378     return resultobj;
20379     fail:
20380     return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_PrintData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20385     PyObject *resultobj;
20386     wxPrintData *arg1 = (wxPrintData *) 0 ;
20387     int result;
20388     PyObject * obj0 = 0 ;
20389     char *kwnames[] = {
20390         (char *) "self", NULL
20391     };
20392
20393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetNoCopies",kwnames,&obj0)) goto fail;
20394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20395     if (SWIG_arg_fail(1)) SWIG_fail;
20396     {
20397         PyThreadState* __tstate = wxPyBeginAllowThreads();
20398         result = (int)(arg1)->GetNoCopies();
20399
20400         wxPyEndAllowThreads(__tstate);
20401         if (PyErr_Occurred()) SWIG_fail;
20402     }
20403     {
20404         resultobj = SWIG_From_int((int)(result));
20405     }
20406     return resultobj;
20407     fail:
20408     return NULL;
20409 }
20410
20411
20412 static PyObject *_wrap_PrintData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20413     PyObject *resultobj;
20414     wxPrintData *arg1 = (wxPrintData *) 0 ;
20415     bool result;
20416     PyObject * obj0 = 0 ;
20417     char *kwnames[] = {
20418         (char *) "self", NULL
20419     };
20420
20421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetCollate",kwnames,&obj0)) goto fail;
20422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20423     if (SWIG_arg_fail(1)) SWIG_fail;
20424     {
20425         PyThreadState* __tstate = wxPyBeginAllowThreads();
20426         result = (bool)(arg1)->GetCollate();
20427
20428         wxPyEndAllowThreads(__tstate);
20429         if (PyErr_Occurred()) SWIG_fail;
20430     }
20431     {
20432         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20433     }
20434     return resultobj;
20435     fail:
20436     return NULL;
20437 }
20438
20439
20440 static PyObject *_wrap_PrintData_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20441     PyObject *resultobj;
20442     wxPrintData *arg1 = (wxPrintData *) 0 ;
20443     int result;
20444     PyObject * obj0 = 0 ;
20445     char *kwnames[] = {
20446         (char *) "self", NULL
20447     };
20448
20449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetOrientation",kwnames,&obj0)) goto fail;
20450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20451     if (SWIG_arg_fail(1)) SWIG_fail;
20452     {
20453         PyThreadState* __tstate = wxPyBeginAllowThreads();
20454         result = (int)(arg1)->GetOrientation();
20455
20456         wxPyEndAllowThreads(__tstate);
20457         if (PyErr_Occurred()) SWIG_fail;
20458     }
20459     {
20460         resultobj = SWIG_From_int((int)(result));
20461     }
20462     return resultobj;
20463     fail:
20464     return NULL;
20465 }
20466
20467
20468 static PyObject *_wrap_PrintData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
20469     PyObject *resultobj;
20470     wxPrintData *arg1 = (wxPrintData *) 0 ;
20471     bool result;
20472     PyObject * obj0 = 0 ;
20473     char *kwnames[] = {
20474         (char *) "self", NULL
20475     };
20476
20477     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_Ok",kwnames,&obj0)) goto fail;
20478     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20479     if (SWIG_arg_fail(1)) SWIG_fail;
20480     {
20481         PyThreadState* __tstate = wxPyBeginAllowThreads();
20482         result = (bool)(arg1)->Ok();
20483
20484         wxPyEndAllowThreads(__tstate);
20485         if (PyErr_Occurred()) SWIG_fail;
20486     }
20487     {
20488         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20489     }
20490     return resultobj;
20491     fail:
20492     return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_PrintData_GetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20497     PyObject *resultobj;
20498     wxPrintData *arg1 = (wxPrintData *) 0 ;
20499     wxString *result;
20500     PyObject * obj0 = 0 ;
20501     char *kwnames[] = {
20502         (char *) "self", NULL
20503     };
20504
20505     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterName",kwnames,&obj0)) goto fail;
20506     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20507     if (SWIG_arg_fail(1)) SWIG_fail;
20508     {
20509         PyThreadState* __tstate = wxPyBeginAllowThreads();
20510         {
20511             wxString const &_result_ref = (arg1)->GetPrinterName();
20512             result = (wxString *) &_result_ref;
20513         }
20514
20515         wxPyEndAllowThreads(__tstate);
20516         if (PyErr_Occurred()) SWIG_fail;
20517     }
20518     {
20519 #if wxUSE_UNICODE
20520         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20521 #else
20522         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20523 #endif
20524     }
20525     return resultobj;
20526     fail:
20527     return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_PrintData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20532     PyObject *resultobj;
20533     wxPrintData *arg1 = (wxPrintData *) 0 ;
20534     bool result;
20535     PyObject * obj0 = 0 ;
20536     char *kwnames[] = {
20537         (char *) "self", NULL
20538     };
20539
20540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetColour",kwnames,&obj0)) goto fail;
20541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20542     if (SWIG_arg_fail(1)) SWIG_fail;
20543     {
20544         PyThreadState* __tstate = wxPyBeginAllowThreads();
20545         result = (bool)(arg1)->GetColour();
20546
20547         wxPyEndAllowThreads(__tstate);
20548         if (PyErr_Occurred()) SWIG_fail;
20549     }
20550     {
20551         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20552     }
20553     return resultobj;
20554     fail:
20555     return NULL;
20556 }
20557
20558
20559 static PyObject *_wrap_PrintData_GetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20560     PyObject *resultobj;
20561     wxPrintData *arg1 = (wxPrintData *) 0 ;
20562     wxDuplexMode result;
20563     PyObject * obj0 = 0 ;
20564     char *kwnames[] = {
20565         (char *) "self", NULL
20566     };
20567
20568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetDuplex",kwnames,&obj0)) goto fail;
20569     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20570     if (SWIG_arg_fail(1)) SWIG_fail;
20571     {
20572         PyThreadState* __tstate = wxPyBeginAllowThreads();
20573         result = (wxDuplexMode)(arg1)->GetDuplex();
20574
20575         wxPyEndAllowThreads(__tstate);
20576         if (PyErr_Occurred()) SWIG_fail;
20577     }
20578     resultobj = SWIG_From_int((result));
20579     return resultobj;
20580     fail:
20581     return NULL;
20582 }
20583
20584
20585 static PyObject *_wrap_PrintData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20586     PyObject *resultobj;
20587     wxPrintData *arg1 = (wxPrintData *) 0 ;
20588     wxPaperSize result;
20589     PyObject * obj0 = 0 ;
20590     char *kwnames[] = {
20591         (char *) "self", NULL
20592     };
20593
20594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperId",kwnames,&obj0)) goto fail;
20595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20596     if (SWIG_arg_fail(1)) SWIG_fail;
20597     {
20598         PyThreadState* __tstate = wxPyBeginAllowThreads();
20599         result = (wxPaperSize)(arg1)->GetPaperId();
20600
20601         wxPyEndAllowThreads(__tstate);
20602         if (PyErr_Occurred()) SWIG_fail;
20603     }
20604     resultobj = SWIG_From_int((result));
20605     return resultobj;
20606     fail:
20607     return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_PrintData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20612     PyObject *resultobj;
20613     wxPrintData *arg1 = (wxPrintData *) 0 ;
20614     wxSize *result;
20615     PyObject * obj0 = 0 ;
20616     char *kwnames[] = {
20617         (char *) "self", NULL
20618     };
20619
20620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperSize",kwnames,&obj0)) goto fail;
20621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20622     if (SWIG_arg_fail(1)) SWIG_fail;
20623     {
20624         PyThreadState* __tstate = wxPyBeginAllowThreads();
20625         {
20626             wxSize const &_result_ref = (arg1)->GetPaperSize();
20627             result = (wxSize *) &_result_ref;
20628         }
20629
20630         wxPyEndAllowThreads(__tstate);
20631         if (PyErr_Occurred()) SWIG_fail;
20632     }
20633     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20634     return resultobj;
20635     fail:
20636     return NULL;
20637 }
20638
20639
20640 static PyObject *_wrap_PrintData_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20641     PyObject *resultobj;
20642     wxPrintData *arg1 = (wxPrintData *) 0 ;
20643     int result;
20644     PyObject * obj0 = 0 ;
20645     char *kwnames[] = {
20646         (char *) "self", NULL
20647     };
20648
20649     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetQuality",kwnames,&obj0)) goto fail;
20650     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20651     if (SWIG_arg_fail(1)) SWIG_fail;
20652     {
20653         PyThreadState* __tstate = wxPyBeginAllowThreads();
20654         result = (int)(arg1)->GetQuality();
20655
20656         wxPyEndAllowThreads(__tstate);
20657         if (PyErr_Occurred()) SWIG_fail;
20658     }
20659     {
20660         resultobj = SWIG_From_int((int)(result));
20661     }
20662     return resultobj;
20663     fail:
20664     return NULL;
20665 }
20666
20667
20668 static PyObject *_wrap_PrintData_GetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20669     PyObject *resultobj;
20670     wxPrintData *arg1 = (wxPrintData *) 0 ;
20671     wxPrintBin result;
20672     PyObject * obj0 = 0 ;
20673     char *kwnames[] = {
20674         (char *) "self", NULL
20675     };
20676
20677     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetBin",kwnames,&obj0)) goto fail;
20678     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20679     if (SWIG_arg_fail(1)) SWIG_fail;
20680     {
20681         PyThreadState* __tstate = wxPyBeginAllowThreads();
20682         result = (wxPrintBin)(arg1)->GetBin();
20683
20684         wxPyEndAllowThreads(__tstate);
20685         if (PyErr_Occurred()) SWIG_fail;
20686     }
20687     resultobj = SWIG_From_int((result));
20688     return resultobj;
20689     fail:
20690     return NULL;
20691 }
20692
20693
20694 static PyObject *_wrap_PrintData_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
20695     PyObject *resultobj;
20696     wxPrintData *arg1 = (wxPrintData *) 0 ;
20697     wxPrintMode result;
20698     PyObject * obj0 = 0 ;
20699     char *kwnames[] = {
20700         (char *) "self", NULL
20701     };
20702
20703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrintMode",kwnames,&obj0)) goto fail;
20704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20705     if (SWIG_arg_fail(1)) SWIG_fail;
20706     {
20707         PyThreadState* __tstate = wxPyBeginAllowThreads();
20708         result = (wxPrintMode)((wxPrintData const *)arg1)->GetPrintMode();
20709
20710         wxPyEndAllowThreads(__tstate);
20711         if (PyErr_Occurred()) SWIG_fail;
20712     }
20713     resultobj = SWIG_From_int((result));
20714     return resultobj;
20715     fail:
20716     return NULL;
20717 }
20718
20719
20720 static PyObject *_wrap_PrintData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20721     PyObject *resultobj;
20722     wxPrintData *arg1 = (wxPrintData *) 0 ;
20723     int arg2 ;
20724     PyObject * obj0 = 0 ;
20725     PyObject * obj1 = 0 ;
20726     char *kwnames[] = {
20727         (char *) "self",(char *) "v", NULL
20728     };
20729
20730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
20731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20732     if (SWIG_arg_fail(1)) SWIG_fail;
20733     {
20734         arg2 = (int)(SWIG_As_int(obj1));
20735         if (SWIG_arg_fail(2)) SWIG_fail;
20736     }
20737     {
20738         PyThreadState* __tstate = wxPyBeginAllowThreads();
20739         (arg1)->SetNoCopies(arg2);
20740
20741         wxPyEndAllowThreads(__tstate);
20742         if (PyErr_Occurred()) SWIG_fail;
20743     }
20744     Py_INCREF(Py_None); resultobj = Py_None;
20745     return resultobj;
20746     fail:
20747     return NULL;
20748 }
20749
20750
20751 static PyObject *_wrap_PrintData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20752     PyObject *resultobj;
20753     wxPrintData *arg1 = (wxPrintData *) 0 ;
20754     bool arg2 ;
20755     PyObject * obj0 = 0 ;
20756     PyObject * obj1 = 0 ;
20757     char *kwnames[] = {
20758         (char *) "self",(char *) "flag", NULL
20759     };
20760
20761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
20762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20763     if (SWIG_arg_fail(1)) SWIG_fail;
20764     {
20765         arg2 = (bool)(SWIG_As_bool(obj1));
20766         if (SWIG_arg_fail(2)) SWIG_fail;
20767     }
20768     {
20769         PyThreadState* __tstate = wxPyBeginAllowThreads();
20770         (arg1)->SetCollate(arg2);
20771
20772         wxPyEndAllowThreads(__tstate);
20773         if (PyErr_Occurred()) SWIG_fail;
20774     }
20775     Py_INCREF(Py_None); resultobj = Py_None;
20776     return resultobj;
20777     fail:
20778     return NULL;
20779 }
20780
20781
20782 static PyObject *_wrap_PrintData_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20783     PyObject *resultobj;
20784     wxPrintData *arg1 = (wxPrintData *) 0 ;
20785     int arg2 ;
20786     PyObject * obj0 = 0 ;
20787     PyObject * obj1 = 0 ;
20788     char *kwnames[] = {
20789         (char *) "self",(char *) "orient", NULL
20790     };
20791
20792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
20793     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20794     if (SWIG_arg_fail(1)) SWIG_fail;
20795     {
20796         arg2 = (int)(SWIG_As_int(obj1));
20797         if (SWIG_arg_fail(2)) SWIG_fail;
20798     }
20799     {
20800         PyThreadState* __tstate = wxPyBeginAllowThreads();
20801         (arg1)->SetOrientation(arg2);
20802
20803         wxPyEndAllowThreads(__tstate);
20804         if (PyErr_Occurred()) SWIG_fail;
20805     }
20806     Py_INCREF(Py_None); resultobj = Py_None;
20807     return resultobj;
20808     fail:
20809     return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_PrintData_SetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20814     PyObject *resultobj;
20815     wxPrintData *arg1 = (wxPrintData *) 0 ;
20816     wxString *arg2 = 0 ;
20817     bool temp2 = false ;
20818     PyObject * obj0 = 0 ;
20819     PyObject * obj1 = 0 ;
20820     char *kwnames[] = {
20821         (char *) "self",(char *) "name", NULL
20822     };
20823
20824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterName",kwnames,&obj0,&obj1)) goto fail;
20825     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20826     if (SWIG_arg_fail(1)) SWIG_fail;
20827     {
20828         arg2 = wxString_in_helper(obj1);
20829         if (arg2 == NULL) SWIG_fail;
20830         temp2 = true;
20831     }
20832     {
20833         PyThreadState* __tstate = wxPyBeginAllowThreads();
20834         (arg1)->SetPrinterName((wxString const &)*arg2);
20835
20836         wxPyEndAllowThreads(__tstate);
20837         if (PyErr_Occurred()) SWIG_fail;
20838     }
20839     Py_INCREF(Py_None); resultobj = Py_None;
20840     {
20841         if (temp2)
20842         delete arg2;
20843     }
20844     return resultobj;
20845     fail:
20846     {
20847         if (temp2)
20848         delete arg2;
20849     }
20850     return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_PrintData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20855     PyObject *resultobj;
20856     wxPrintData *arg1 = (wxPrintData *) 0 ;
20857     bool arg2 ;
20858     PyObject * obj0 = 0 ;
20859     PyObject * obj1 = 0 ;
20860     char *kwnames[] = {
20861         (char *) "self",(char *) "colour", NULL
20862     };
20863
20864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetColour",kwnames,&obj0,&obj1)) goto fail;
20865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20866     if (SWIG_arg_fail(1)) SWIG_fail;
20867     {
20868         arg2 = (bool)(SWIG_As_bool(obj1));
20869         if (SWIG_arg_fail(2)) SWIG_fail;
20870     }
20871     {
20872         PyThreadState* __tstate = wxPyBeginAllowThreads();
20873         (arg1)->SetColour(arg2);
20874
20875         wxPyEndAllowThreads(__tstate);
20876         if (PyErr_Occurred()) SWIG_fail;
20877     }
20878     Py_INCREF(Py_None); resultobj = Py_None;
20879     return resultobj;
20880     fail:
20881     return NULL;
20882 }
20883
20884
20885 static PyObject *_wrap_PrintData_SetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20886     PyObject *resultobj;
20887     wxPrintData *arg1 = (wxPrintData *) 0 ;
20888     wxDuplexMode arg2 ;
20889     PyObject * obj0 = 0 ;
20890     PyObject * obj1 = 0 ;
20891     char *kwnames[] = {
20892         (char *) "self",(char *) "duplex", NULL
20893     };
20894
20895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetDuplex",kwnames,&obj0,&obj1)) goto fail;
20896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20897     if (SWIG_arg_fail(1)) SWIG_fail;
20898     {
20899         arg2 = (wxDuplexMode)(SWIG_As_int(obj1));
20900         if (SWIG_arg_fail(2)) SWIG_fail;
20901     }
20902     {
20903         PyThreadState* __tstate = wxPyBeginAllowThreads();
20904         (arg1)->SetDuplex((wxDuplexMode )arg2);
20905
20906         wxPyEndAllowThreads(__tstate);
20907         if (PyErr_Occurred()) SWIG_fail;
20908     }
20909     Py_INCREF(Py_None); resultobj = Py_None;
20910     return resultobj;
20911     fail:
20912     return NULL;
20913 }
20914
20915
20916 static PyObject *_wrap_PrintData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20917     PyObject *resultobj;
20918     wxPrintData *arg1 = (wxPrintData *) 0 ;
20919     wxPaperSize arg2 ;
20920     PyObject * obj0 = 0 ;
20921     PyObject * obj1 = 0 ;
20922     char *kwnames[] = {
20923         (char *) "self",(char *) "sizeId", NULL
20924     };
20925
20926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
20927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20928     if (SWIG_arg_fail(1)) SWIG_fail;
20929     {
20930         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
20931         if (SWIG_arg_fail(2)) SWIG_fail;
20932     }
20933     {
20934         PyThreadState* __tstate = wxPyBeginAllowThreads();
20935         (arg1)->SetPaperId((wxPaperSize )arg2);
20936
20937         wxPyEndAllowThreads(__tstate);
20938         if (PyErr_Occurred()) SWIG_fail;
20939     }
20940     Py_INCREF(Py_None); resultobj = Py_None;
20941     return resultobj;
20942     fail:
20943     return NULL;
20944 }
20945
20946
20947 static PyObject *_wrap_PrintData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20948     PyObject *resultobj;
20949     wxPrintData *arg1 = (wxPrintData *) 0 ;
20950     wxSize *arg2 = 0 ;
20951     wxSize temp2 ;
20952     PyObject * obj0 = 0 ;
20953     PyObject * obj1 = 0 ;
20954     char *kwnames[] = {
20955         (char *) "self",(char *) "sz", NULL
20956     };
20957
20958     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
20959     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20960     if (SWIG_arg_fail(1)) SWIG_fail;
20961     {
20962         arg2 = &temp2;
20963         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20964     }
20965     {
20966         PyThreadState* __tstate = wxPyBeginAllowThreads();
20967         (arg1)->SetPaperSize((wxSize const &)*arg2);
20968
20969         wxPyEndAllowThreads(__tstate);
20970         if (PyErr_Occurred()) SWIG_fail;
20971     }
20972     Py_INCREF(Py_None); resultobj = Py_None;
20973     return resultobj;
20974     fail:
20975     return NULL;
20976 }
20977
20978
20979 static PyObject *_wrap_PrintData_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20980     PyObject *resultobj;
20981     wxPrintData *arg1 = (wxPrintData *) 0 ;
20982     int arg2 ;
20983     PyObject * obj0 = 0 ;
20984     PyObject * obj1 = 0 ;
20985     char *kwnames[] = {
20986         (char *) "self",(char *) "quality", NULL
20987     };
20988
20989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
20990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20991     if (SWIG_arg_fail(1)) SWIG_fail;
20992     {
20993         arg2 = (int)(SWIG_As_int(obj1));
20994         if (SWIG_arg_fail(2)) SWIG_fail;
20995     }
20996     {
20997         PyThreadState* __tstate = wxPyBeginAllowThreads();
20998         (arg1)->SetQuality(arg2);
20999
21000         wxPyEndAllowThreads(__tstate);
21001         if (PyErr_Occurred()) SWIG_fail;
21002     }
21003     Py_INCREF(Py_None); resultobj = Py_None;
21004     return resultobj;
21005     fail:
21006     return NULL;
21007 }
21008
21009
21010 static PyObject *_wrap_PrintData_SetBin(PyObject *, PyObject *args, PyObject *kwargs) {
21011     PyObject *resultobj;
21012     wxPrintData *arg1 = (wxPrintData *) 0 ;
21013     wxPrintBin arg2 ;
21014     PyObject * obj0 = 0 ;
21015     PyObject * obj1 = 0 ;
21016     char *kwnames[] = {
21017         (char *) "self",(char *) "bin", NULL
21018     };
21019
21020     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetBin",kwnames,&obj0,&obj1)) goto fail;
21021     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21022     if (SWIG_arg_fail(1)) SWIG_fail;
21023     {
21024         arg2 = (wxPrintBin)(SWIG_As_int(obj1));
21025         if (SWIG_arg_fail(2)) SWIG_fail;
21026     }
21027     {
21028         PyThreadState* __tstate = wxPyBeginAllowThreads();
21029         (arg1)->SetBin((wxPrintBin )arg2);
21030
21031         wxPyEndAllowThreads(__tstate);
21032         if (PyErr_Occurred()) SWIG_fail;
21033     }
21034     Py_INCREF(Py_None); resultobj = Py_None;
21035     return resultobj;
21036     fail:
21037     return NULL;
21038 }
21039
21040
21041 static PyObject *_wrap_PrintData_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
21042     PyObject *resultobj;
21043     wxPrintData *arg1 = (wxPrintData *) 0 ;
21044     wxPrintMode arg2 ;
21045     PyObject * obj0 = 0 ;
21046     PyObject * obj1 = 0 ;
21047     char *kwnames[] = {
21048         (char *) "self",(char *) "printMode", NULL
21049     };
21050
21051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
21052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21053     if (SWIG_arg_fail(1)) SWIG_fail;
21054     {
21055         arg2 = (wxPrintMode)(SWIG_As_int(obj1));
21056         if (SWIG_arg_fail(2)) SWIG_fail;
21057     }
21058     {
21059         PyThreadState* __tstate = wxPyBeginAllowThreads();
21060         (arg1)->SetPrintMode((wxPrintMode )arg2);
21061
21062         wxPyEndAllowThreads(__tstate);
21063         if (PyErr_Occurred()) SWIG_fail;
21064     }
21065     Py_INCREF(Py_None); resultobj = Py_None;
21066     return resultobj;
21067     fail:
21068     return NULL;
21069 }
21070
21071
21072 static PyObject *_wrap_PrintData_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21073     PyObject *resultobj;
21074     wxPrintData *arg1 = (wxPrintData *) 0 ;
21075     wxString result;
21076     PyObject * obj0 = 0 ;
21077     char *kwnames[] = {
21078         (char *) "self", NULL
21079     };
21080
21081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFilename",kwnames,&obj0)) goto fail;
21082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21083     if (SWIG_arg_fail(1)) SWIG_fail;
21084     {
21085         PyThreadState* __tstate = wxPyBeginAllowThreads();
21086         result = ((wxPrintData const *)arg1)->GetFilename();
21087
21088         wxPyEndAllowThreads(__tstate);
21089         if (PyErr_Occurred()) SWIG_fail;
21090     }
21091     {
21092 #if wxUSE_UNICODE
21093         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21094 #else
21095         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21096 #endif
21097     }
21098     return resultobj;
21099     fail:
21100     return NULL;
21101 }
21102
21103
21104 static PyObject *_wrap_PrintData_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21105     PyObject *resultobj;
21106     wxPrintData *arg1 = (wxPrintData *) 0 ;
21107     wxString *arg2 = 0 ;
21108     bool temp2 = false ;
21109     PyObject * obj0 = 0 ;
21110     PyObject * obj1 = 0 ;
21111     char *kwnames[] = {
21112         (char *) "self",(char *) "filename", NULL
21113     };
21114
21115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFilename",kwnames,&obj0,&obj1)) goto fail;
21116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21117     if (SWIG_arg_fail(1)) SWIG_fail;
21118     {
21119         arg2 = wxString_in_helper(obj1);
21120         if (arg2 == NULL) SWIG_fail;
21121         temp2 = true;
21122     }
21123     {
21124         PyThreadState* __tstate = wxPyBeginAllowThreads();
21125         (arg1)->SetFilename((wxString const &)*arg2);
21126
21127         wxPyEndAllowThreads(__tstate);
21128         if (PyErr_Occurred()) SWIG_fail;
21129     }
21130     Py_INCREF(Py_None); resultobj = Py_None;
21131     {
21132         if (temp2)
21133         delete arg2;
21134     }
21135     return resultobj;
21136     fail:
21137     {
21138         if (temp2)
21139         delete arg2;
21140     }
21141     return NULL;
21142 }
21143
21144
21145 static PyObject *_wrap_PrintData_GetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21146     PyObject *resultobj;
21147     wxPrintData *arg1 = (wxPrintData *) 0 ;
21148     PyObject *result;
21149     PyObject * obj0 = 0 ;
21150     char *kwnames[] = {
21151         (char *) "self", NULL
21152     };
21153
21154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrivData",kwnames,&obj0)) goto fail;
21155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21156     if (SWIG_arg_fail(1)) SWIG_fail;
21157     {
21158         PyThreadState* __tstate = wxPyBeginAllowThreads();
21159         result = (PyObject *)wxPrintData_GetPrivData(arg1);
21160
21161         wxPyEndAllowThreads(__tstate);
21162         if (PyErr_Occurred()) SWIG_fail;
21163     }
21164     resultobj = result;
21165     return resultobj;
21166     fail:
21167     return NULL;
21168 }
21169
21170
21171 static PyObject *_wrap_PrintData_SetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21172     PyObject *resultobj;
21173     wxPrintData *arg1 = (wxPrintData *) 0 ;
21174     PyObject *arg2 = (PyObject *) 0 ;
21175     PyObject * obj0 = 0 ;
21176     PyObject * obj1 = 0 ;
21177     char *kwnames[] = {
21178         (char *) "self",(char *) "data", NULL
21179     };
21180
21181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrivData",kwnames,&obj0,&obj1)) goto fail;
21182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21183     if (SWIG_arg_fail(1)) SWIG_fail;
21184     arg2 = obj1;
21185     {
21186         PyThreadState* __tstate = wxPyBeginAllowThreads();
21187         wxPrintData_SetPrivData(arg1,arg2);
21188
21189         wxPyEndAllowThreads(__tstate);
21190         if (PyErr_Occurred()) SWIG_fail;
21191     }
21192     Py_INCREF(Py_None); resultobj = Py_None;
21193     return resultobj;
21194     fail:
21195     return NULL;
21196 }
21197
21198
21199 static PyObject *_wrap_PrintData_GetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21200     PyObject *resultobj;
21201     wxPrintData *arg1 = (wxPrintData *) 0 ;
21202     wxString *result;
21203     PyObject * obj0 = 0 ;
21204     char *kwnames[] = {
21205         (char *) "self", NULL
21206     };
21207
21208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterCommand",kwnames,&obj0)) goto fail;
21209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21210     if (SWIG_arg_fail(1)) SWIG_fail;
21211     {
21212         PyThreadState* __tstate = wxPyBeginAllowThreads();
21213         {
21214             wxString const &_result_ref = (arg1)->GetPrinterCommand();
21215             result = (wxString *) &_result_ref;
21216         }
21217
21218         wxPyEndAllowThreads(__tstate);
21219         if (PyErr_Occurred()) SWIG_fail;
21220     }
21221     {
21222 #if wxUSE_UNICODE
21223         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21224 #else
21225         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21226 #endif
21227     }
21228     return resultobj;
21229     fail:
21230     return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_PrintData_GetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21235     PyObject *resultobj;
21236     wxPrintData *arg1 = (wxPrintData *) 0 ;
21237     wxString *result;
21238     PyObject * obj0 = 0 ;
21239     char *kwnames[] = {
21240         (char *) "self", NULL
21241     };
21242
21243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterOptions",kwnames,&obj0)) goto fail;
21244     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21245     if (SWIG_arg_fail(1)) SWIG_fail;
21246     {
21247         PyThreadState* __tstate = wxPyBeginAllowThreads();
21248         {
21249             wxString const &_result_ref = (arg1)->GetPrinterOptions();
21250             result = (wxString *) &_result_ref;
21251         }
21252
21253         wxPyEndAllowThreads(__tstate);
21254         if (PyErr_Occurred()) SWIG_fail;
21255     }
21256     {
21257 #if wxUSE_UNICODE
21258         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21259 #else
21260         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21261 #endif
21262     }
21263     return resultobj;
21264     fail:
21265     return NULL;
21266 }
21267
21268
21269 static PyObject *_wrap_PrintData_GetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21270     PyObject *resultobj;
21271     wxPrintData *arg1 = (wxPrintData *) 0 ;
21272     wxString *result;
21273     PyObject * obj0 = 0 ;
21274     char *kwnames[] = {
21275         (char *) "self", NULL
21276     };
21277
21278     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPreviewCommand",kwnames,&obj0)) goto fail;
21279     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21280     if (SWIG_arg_fail(1)) SWIG_fail;
21281     {
21282         PyThreadState* __tstate = wxPyBeginAllowThreads();
21283         {
21284             wxString const &_result_ref = (arg1)->GetPreviewCommand();
21285             result = (wxString *) &_result_ref;
21286         }
21287
21288         wxPyEndAllowThreads(__tstate);
21289         if (PyErr_Occurred()) SWIG_fail;
21290     }
21291     {
21292 #if wxUSE_UNICODE
21293         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21294 #else
21295         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21296 #endif
21297     }
21298     return resultobj;
21299     fail:
21300     return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_PrintData_GetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21305     PyObject *resultobj;
21306     wxPrintData *arg1 = (wxPrintData *) 0 ;
21307     wxString *result;
21308     PyObject * obj0 = 0 ;
21309     char *kwnames[] = {
21310         (char *) "self", NULL
21311     };
21312
21313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFontMetricPath",kwnames,&obj0)) goto fail;
21314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21315     if (SWIG_arg_fail(1)) SWIG_fail;
21316     {
21317         PyThreadState* __tstate = wxPyBeginAllowThreads();
21318         {
21319             wxString const &_result_ref = (arg1)->GetFontMetricPath();
21320             result = (wxString *) &_result_ref;
21321         }
21322
21323         wxPyEndAllowThreads(__tstate);
21324         if (PyErr_Occurred()) SWIG_fail;
21325     }
21326     {
21327 #if wxUSE_UNICODE
21328         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21329 #else
21330         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21331 #endif
21332     }
21333     return resultobj;
21334     fail:
21335     return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_PrintData_GetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21340     PyObject *resultobj;
21341     wxPrintData *arg1 = (wxPrintData *) 0 ;
21342     double result;
21343     PyObject * obj0 = 0 ;
21344     char *kwnames[] = {
21345         (char *) "self", NULL
21346     };
21347
21348     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleX",kwnames,&obj0)) goto fail;
21349     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21350     if (SWIG_arg_fail(1)) SWIG_fail;
21351     {
21352         PyThreadState* __tstate = wxPyBeginAllowThreads();
21353         result = (double)(arg1)->GetPrinterScaleX();
21354
21355         wxPyEndAllowThreads(__tstate);
21356         if (PyErr_Occurred()) SWIG_fail;
21357     }
21358     {
21359         resultobj = SWIG_From_double((double)(result));
21360     }
21361     return resultobj;
21362     fail:
21363     return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_PrintData_GetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21368     PyObject *resultobj;
21369     wxPrintData *arg1 = (wxPrintData *) 0 ;
21370     double result;
21371     PyObject * obj0 = 0 ;
21372     char *kwnames[] = {
21373         (char *) "self", NULL
21374     };
21375
21376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleY",kwnames,&obj0)) goto fail;
21377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21378     if (SWIG_arg_fail(1)) SWIG_fail;
21379     {
21380         PyThreadState* __tstate = wxPyBeginAllowThreads();
21381         result = (double)(arg1)->GetPrinterScaleY();
21382
21383         wxPyEndAllowThreads(__tstate);
21384         if (PyErr_Occurred()) SWIG_fail;
21385     }
21386     {
21387         resultobj = SWIG_From_double((double)(result));
21388     }
21389     return resultobj;
21390     fail:
21391     return NULL;
21392 }
21393
21394
21395 static PyObject *_wrap_PrintData_GetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21396     PyObject *resultobj;
21397     wxPrintData *arg1 = (wxPrintData *) 0 ;
21398     long result;
21399     PyObject * obj0 = 0 ;
21400     char *kwnames[] = {
21401         (char *) "self", NULL
21402     };
21403
21404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateX",kwnames,&obj0)) goto fail;
21405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21406     if (SWIG_arg_fail(1)) SWIG_fail;
21407     {
21408         PyThreadState* __tstate = wxPyBeginAllowThreads();
21409         result = (long)(arg1)->GetPrinterTranslateX();
21410
21411         wxPyEndAllowThreads(__tstate);
21412         if (PyErr_Occurred()) SWIG_fail;
21413     }
21414     {
21415         resultobj = SWIG_From_long((long)(result));
21416     }
21417     return resultobj;
21418     fail:
21419     return NULL;
21420 }
21421
21422
21423 static PyObject *_wrap_PrintData_GetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21424     PyObject *resultobj;
21425     wxPrintData *arg1 = (wxPrintData *) 0 ;
21426     long result;
21427     PyObject * obj0 = 0 ;
21428     char *kwnames[] = {
21429         (char *) "self", NULL
21430     };
21431
21432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateY",kwnames,&obj0)) goto fail;
21433     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21434     if (SWIG_arg_fail(1)) SWIG_fail;
21435     {
21436         PyThreadState* __tstate = wxPyBeginAllowThreads();
21437         result = (long)(arg1)->GetPrinterTranslateY();
21438
21439         wxPyEndAllowThreads(__tstate);
21440         if (PyErr_Occurred()) SWIG_fail;
21441     }
21442     {
21443         resultobj = SWIG_From_long((long)(result));
21444     }
21445     return resultobj;
21446     fail:
21447     return NULL;
21448 }
21449
21450
21451 static PyObject *_wrap_PrintData_SetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21452     PyObject *resultobj;
21453     wxPrintData *arg1 = (wxPrintData *) 0 ;
21454     wxString *arg2 = 0 ;
21455     bool temp2 = false ;
21456     PyObject * obj0 = 0 ;
21457     PyObject * obj1 = 0 ;
21458     char *kwnames[] = {
21459         (char *) "self",(char *) "command", NULL
21460     };
21461
21462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterCommand",kwnames,&obj0,&obj1)) goto fail;
21463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21464     if (SWIG_arg_fail(1)) SWIG_fail;
21465     {
21466         arg2 = wxString_in_helper(obj1);
21467         if (arg2 == NULL) SWIG_fail;
21468         temp2 = true;
21469     }
21470     {
21471         PyThreadState* __tstate = wxPyBeginAllowThreads();
21472         (arg1)->SetPrinterCommand((wxString const &)*arg2);
21473
21474         wxPyEndAllowThreads(__tstate);
21475         if (PyErr_Occurred()) SWIG_fail;
21476     }
21477     Py_INCREF(Py_None); resultobj = Py_None;
21478     {
21479         if (temp2)
21480         delete arg2;
21481     }
21482     return resultobj;
21483     fail:
21484     {
21485         if (temp2)
21486         delete arg2;
21487     }
21488     return NULL;
21489 }
21490
21491
21492 static PyObject *_wrap_PrintData_SetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21493     PyObject *resultobj;
21494     wxPrintData *arg1 = (wxPrintData *) 0 ;
21495     wxString *arg2 = 0 ;
21496     bool temp2 = false ;
21497     PyObject * obj0 = 0 ;
21498     PyObject * obj1 = 0 ;
21499     char *kwnames[] = {
21500         (char *) "self",(char *) "options", NULL
21501     };
21502
21503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterOptions",kwnames,&obj0,&obj1)) goto fail;
21504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21505     if (SWIG_arg_fail(1)) SWIG_fail;
21506     {
21507         arg2 = wxString_in_helper(obj1);
21508         if (arg2 == NULL) SWIG_fail;
21509         temp2 = true;
21510     }
21511     {
21512         PyThreadState* __tstate = wxPyBeginAllowThreads();
21513         (arg1)->SetPrinterOptions((wxString const &)*arg2);
21514
21515         wxPyEndAllowThreads(__tstate);
21516         if (PyErr_Occurred()) SWIG_fail;
21517     }
21518     Py_INCREF(Py_None); resultobj = Py_None;
21519     {
21520         if (temp2)
21521         delete arg2;
21522     }
21523     return resultobj;
21524     fail:
21525     {
21526         if (temp2)
21527         delete arg2;
21528     }
21529     return NULL;
21530 }
21531
21532
21533 static PyObject *_wrap_PrintData_SetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21534     PyObject *resultobj;
21535     wxPrintData *arg1 = (wxPrintData *) 0 ;
21536     wxString *arg2 = 0 ;
21537     bool temp2 = false ;
21538     PyObject * obj0 = 0 ;
21539     PyObject * obj1 = 0 ;
21540     char *kwnames[] = {
21541         (char *) "self",(char *) "command", NULL
21542     };
21543
21544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPreviewCommand",kwnames,&obj0,&obj1)) goto fail;
21545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21546     if (SWIG_arg_fail(1)) SWIG_fail;
21547     {
21548         arg2 = wxString_in_helper(obj1);
21549         if (arg2 == NULL) SWIG_fail;
21550         temp2 = true;
21551     }
21552     {
21553         PyThreadState* __tstate = wxPyBeginAllowThreads();
21554         (arg1)->SetPreviewCommand((wxString const &)*arg2);
21555
21556         wxPyEndAllowThreads(__tstate);
21557         if (PyErr_Occurred()) SWIG_fail;
21558     }
21559     Py_INCREF(Py_None); resultobj = Py_None;
21560     {
21561         if (temp2)
21562         delete arg2;
21563     }
21564     return resultobj;
21565     fail:
21566     {
21567         if (temp2)
21568         delete arg2;
21569     }
21570     return NULL;
21571 }
21572
21573
21574 static PyObject *_wrap_PrintData_SetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21575     PyObject *resultobj;
21576     wxPrintData *arg1 = (wxPrintData *) 0 ;
21577     wxString *arg2 = 0 ;
21578     bool temp2 = false ;
21579     PyObject * obj0 = 0 ;
21580     PyObject * obj1 = 0 ;
21581     char *kwnames[] = {
21582         (char *) "self",(char *) "path", NULL
21583     };
21584
21585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFontMetricPath",kwnames,&obj0,&obj1)) goto fail;
21586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21587     if (SWIG_arg_fail(1)) SWIG_fail;
21588     {
21589         arg2 = wxString_in_helper(obj1);
21590         if (arg2 == NULL) SWIG_fail;
21591         temp2 = true;
21592     }
21593     {
21594         PyThreadState* __tstate = wxPyBeginAllowThreads();
21595         (arg1)->SetFontMetricPath((wxString const &)*arg2);
21596
21597         wxPyEndAllowThreads(__tstate);
21598         if (PyErr_Occurred()) SWIG_fail;
21599     }
21600     Py_INCREF(Py_None); resultobj = Py_None;
21601     {
21602         if (temp2)
21603         delete arg2;
21604     }
21605     return resultobj;
21606     fail:
21607     {
21608         if (temp2)
21609         delete arg2;
21610     }
21611     return NULL;
21612 }
21613
21614
21615 static PyObject *_wrap_PrintData_SetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21616     PyObject *resultobj;
21617     wxPrintData *arg1 = (wxPrintData *) 0 ;
21618     double arg2 ;
21619     PyObject * obj0 = 0 ;
21620     PyObject * obj1 = 0 ;
21621     char *kwnames[] = {
21622         (char *) "self",(char *) "x", NULL
21623     };
21624
21625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleX",kwnames,&obj0,&obj1)) goto fail;
21626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21627     if (SWIG_arg_fail(1)) SWIG_fail;
21628     {
21629         arg2 = (double)(SWIG_As_double(obj1));
21630         if (SWIG_arg_fail(2)) SWIG_fail;
21631     }
21632     {
21633         PyThreadState* __tstate = wxPyBeginAllowThreads();
21634         (arg1)->SetPrinterScaleX(arg2);
21635
21636         wxPyEndAllowThreads(__tstate);
21637         if (PyErr_Occurred()) SWIG_fail;
21638     }
21639     Py_INCREF(Py_None); resultobj = Py_None;
21640     return resultobj;
21641     fail:
21642     return NULL;
21643 }
21644
21645
21646 static PyObject *_wrap_PrintData_SetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21647     PyObject *resultobj;
21648     wxPrintData *arg1 = (wxPrintData *) 0 ;
21649     double arg2 ;
21650     PyObject * obj0 = 0 ;
21651     PyObject * obj1 = 0 ;
21652     char *kwnames[] = {
21653         (char *) "self",(char *) "y", NULL
21654     };
21655
21656     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleY",kwnames,&obj0,&obj1)) goto fail;
21657     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21658     if (SWIG_arg_fail(1)) SWIG_fail;
21659     {
21660         arg2 = (double)(SWIG_As_double(obj1));
21661         if (SWIG_arg_fail(2)) SWIG_fail;
21662     }
21663     {
21664         PyThreadState* __tstate = wxPyBeginAllowThreads();
21665         (arg1)->SetPrinterScaleY(arg2);
21666
21667         wxPyEndAllowThreads(__tstate);
21668         if (PyErr_Occurred()) SWIG_fail;
21669     }
21670     Py_INCREF(Py_None); resultobj = Py_None;
21671     return resultobj;
21672     fail:
21673     return NULL;
21674 }
21675
21676
21677 static PyObject *_wrap_PrintData_SetPrinterScaling(PyObject *, PyObject *args, PyObject *kwargs) {
21678     PyObject *resultobj;
21679     wxPrintData *arg1 = (wxPrintData *) 0 ;
21680     double arg2 ;
21681     double arg3 ;
21682     PyObject * obj0 = 0 ;
21683     PyObject * obj1 = 0 ;
21684     PyObject * obj2 = 0 ;
21685     char *kwnames[] = {
21686         (char *) "self",(char *) "x",(char *) "y", NULL
21687     };
21688
21689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterScaling",kwnames,&obj0,&obj1,&obj2)) goto fail;
21690     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21691     if (SWIG_arg_fail(1)) SWIG_fail;
21692     {
21693         arg2 = (double)(SWIG_As_double(obj1));
21694         if (SWIG_arg_fail(2)) SWIG_fail;
21695     }
21696     {
21697         arg3 = (double)(SWIG_As_double(obj2));
21698         if (SWIG_arg_fail(3)) SWIG_fail;
21699     }
21700     {
21701         PyThreadState* __tstate = wxPyBeginAllowThreads();
21702         (arg1)->SetPrinterScaling(arg2,arg3);
21703
21704         wxPyEndAllowThreads(__tstate);
21705         if (PyErr_Occurred()) SWIG_fail;
21706     }
21707     Py_INCREF(Py_None); resultobj = Py_None;
21708     return resultobj;
21709     fail:
21710     return NULL;
21711 }
21712
21713
21714 static PyObject *_wrap_PrintData_SetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21715     PyObject *resultobj;
21716     wxPrintData *arg1 = (wxPrintData *) 0 ;
21717     long arg2 ;
21718     PyObject * obj0 = 0 ;
21719     PyObject * obj1 = 0 ;
21720     char *kwnames[] = {
21721         (char *) "self",(char *) "x", NULL
21722     };
21723
21724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateX",kwnames,&obj0,&obj1)) goto fail;
21725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21726     if (SWIG_arg_fail(1)) SWIG_fail;
21727     {
21728         arg2 = (long)(SWIG_As_long(obj1));
21729         if (SWIG_arg_fail(2)) SWIG_fail;
21730     }
21731     {
21732         PyThreadState* __tstate = wxPyBeginAllowThreads();
21733         (arg1)->SetPrinterTranslateX(arg2);
21734
21735         wxPyEndAllowThreads(__tstate);
21736         if (PyErr_Occurred()) SWIG_fail;
21737     }
21738     Py_INCREF(Py_None); resultobj = Py_None;
21739     return resultobj;
21740     fail:
21741     return NULL;
21742 }
21743
21744
21745 static PyObject *_wrap_PrintData_SetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21746     PyObject *resultobj;
21747     wxPrintData *arg1 = (wxPrintData *) 0 ;
21748     long arg2 ;
21749     PyObject * obj0 = 0 ;
21750     PyObject * obj1 = 0 ;
21751     char *kwnames[] = {
21752         (char *) "self",(char *) "y", NULL
21753     };
21754
21755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateY",kwnames,&obj0,&obj1)) goto fail;
21756     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21757     if (SWIG_arg_fail(1)) SWIG_fail;
21758     {
21759         arg2 = (long)(SWIG_As_long(obj1));
21760         if (SWIG_arg_fail(2)) SWIG_fail;
21761     }
21762     {
21763         PyThreadState* __tstate = wxPyBeginAllowThreads();
21764         (arg1)->SetPrinterTranslateY(arg2);
21765
21766         wxPyEndAllowThreads(__tstate);
21767         if (PyErr_Occurred()) SWIG_fail;
21768     }
21769     Py_INCREF(Py_None); resultobj = Py_None;
21770     return resultobj;
21771     fail:
21772     return NULL;
21773 }
21774
21775
21776 static PyObject *_wrap_PrintData_SetPrinterTranslation(PyObject *, PyObject *args, PyObject *kwargs) {
21777     PyObject *resultobj;
21778     wxPrintData *arg1 = (wxPrintData *) 0 ;
21779     long arg2 ;
21780     long arg3 ;
21781     PyObject * obj0 = 0 ;
21782     PyObject * obj1 = 0 ;
21783     PyObject * obj2 = 0 ;
21784     char *kwnames[] = {
21785         (char *) "self",(char *) "x",(char *) "y", NULL
21786     };
21787
21788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterTranslation",kwnames,&obj0,&obj1,&obj2)) goto fail;
21789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21790     if (SWIG_arg_fail(1)) SWIG_fail;
21791     {
21792         arg2 = (long)(SWIG_As_long(obj1));
21793         if (SWIG_arg_fail(2)) SWIG_fail;
21794     }
21795     {
21796         arg3 = (long)(SWIG_As_long(obj2));
21797         if (SWIG_arg_fail(3)) SWIG_fail;
21798     }
21799     {
21800         PyThreadState* __tstate = wxPyBeginAllowThreads();
21801         (arg1)->SetPrinterTranslation(arg2,arg3);
21802
21803         wxPyEndAllowThreads(__tstate);
21804         if (PyErr_Occurred()) SWIG_fail;
21805     }
21806     Py_INCREF(Py_None); resultobj = Py_None;
21807     return resultobj;
21808     fail:
21809     return NULL;
21810 }
21811
21812
21813 static PyObject * PrintData_swigregister(PyObject *, PyObject *args) {
21814     PyObject *obj;
21815     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21816     SWIG_TypeClientData(SWIGTYPE_p_wxPrintData, obj);
21817     Py_INCREF(obj);
21818     return Py_BuildValue((char *)"");
21819 }
21820 static PyObject *_wrap_new_PageSetupDialogData__SWIG_0(PyObject *, PyObject *args) {
21821     PyObject *resultobj;
21822     wxPageSetupDialogData *result;
21823
21824     if(!PyArg_ParseTuple(args,(char *)":new_PageSetupDialogData")) goto fail;
21825     {
21826         PyThreadState* __tstate = wxPyBeginAllowThreads();
21827         result = (wxPageSetupDialogData *)new wxPageSetupDialogData();
21828
21829         wxPyEndAllowThreads(__tstate);
21830         if (PyErr_Occurred()) SWIG_fail;
21831     }
21832     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21833     return resultobj;
21834     fail:
21835     return NULL;
21836 }
21837
21838
21839 static PyObject *_wrap_new_PageSetupDialogData__SWIG_1(PyObject *, PyObject *args) {
21840     PyObject *resultobj;
21841     wxPageSetupDialogData *arg1 = 0 ;
21842     wxPageSetupDialogData *result;
21843     PyObject * obj0 = 0 ;
21844
21845     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21846     {
21847         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21848         if (SWIG_arg_fail(1)) SWIG_fail;
21849         if (arg1 == NULL) {
21850             SWIG_null_ref("wxPageSetupDialogData");
21851         }
21852         if (SWIG_arg_fail(1)) SWIG_fail;
21853     }
21854     {
21855         PyThreadState* __tstate = wxPyBeginAllowThreads();
21856         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPageSetupDialogData const &)*arg1);
21857
21858         wxPyEndAllowThreads(__tstate);
21859         if (PyErr_Occurred()) SWIG_fail;
21860     }
21861     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21862     return resultobj;
21863     fail:
21864     return NULL;
21865 }
21866
21867
21868 static PyObject *_wrap_new_PageSetupDialogData__SWIG_2(PyObject *, PyObject *args) {
21869     PyObject *resultobj;
21870     wxPrintData *arg1 = 0 ;
21871     wxPageSetupDialogData *result;
21872     PyObject * obj0 = 0 ;
21873
21874     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21875     {
21876         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21877         if (SWIG_arg_fail(1)) SWIG_fail;
21878         if (arg1 == NULL) {
21879             SWIG_null_ref("wxPrintData");
21880         }
21881         if (SWIG_arg_fail(1)) SWIG_fail;
21882     }
21883     {
21884         PyThreadState* __tstate = wxPyBeginAllowThreads();
21885         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPrintData const &)*arg1);
21886
21887         wxPyEndAllowThreads(__tstate);
21888         if (PyErr_Occurred()) SWIG_fail;
21889     }
21890     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21891     return resultobj;
21892     fail:
21893     return NULL;
21894 }
21895
21896
21897 static PyObject *_wrap_new_PageSetupDialogData(PyObject *self, PyObject *args) {
21898     int argc;
21899     PyObject *argv[2];
21900     int ii;
21901
21902     argc = PyObject_Length(args);
21903     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
21904         argv[ii] = PyTuple_GetItem(args,ii);
21905     }
21906     if (argc == 0) {
21907         return _wrap_new_PageSetupDialogData__SWIG_0(self,args);
21908     }
21909     if (argc == 1) {
21910         int _v;
21911         {
21912             void *ptr = 0;
21913             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPageSetupDialogData, 0) == -1) {
21914                 _v = 0;
21915                 PyErr_Clear();
21916             } else {
21917                 _v = (ptr != 0);
21918             }
21919         }
21920         if (_v) {
21921             return _wrap_new_PageSetupDialogData__SWIG_1(self,args);
21922         }
21923     }
21924     if (argc == 1) {
21925         int _v;
21926         {
21927             void *ptr = 0;
21928             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
21929                 _v = 0;
21930                 PyErr_Clear();
21931             } else {
21932                 _v = (ptr != 0);
21933             }
21934         }
21935         if (_v) {
21936             return _wrap_new_PageSetupDialogData__SWIG_2(self,args);
21937         }
21938     }
21939
21940     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PageSetupDialogData'");
21941     return NULL;
21942 }
21943
21944
21945 static PyObject *_wrap_delete_PageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
21946     PyObject *resultobj;
21947     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21948     PyObject * obj0 = 0 ;
21949     char *kwnames[] = {
21950         (char *) "self", NULL
21951     };
21952
21953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PageSetupDialogData",kwnames,&obj0)) goto fail;
21954     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21955     if (SWIG_arg_fail(1)) SWIG_fail;
21956     {
21957         PyThreadState* __tstate = wxPyBeginAllowThreads();
21958         delete arg1;
21959
21960         wxPyEndAllowThreads(__tstate);
21961         if (PyErr_Occurred()) SWIG_fail;
21962     }
21963     Py_INCREF(Py_None); resultobj = Py_None;
21964     return resultobj;
21965     fail:
21966     return NULL;
21967 }
21968
21969
21970 static PyObject *_wrap_PageSetupDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
21971     PyObject *resultobj;
21972     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21973     bool arg2 ;
21974     PyObject * obj0 = 0 ;
21975     PyObject * obj1 = 0 ;
21976     char *kwnames[] = {
21977         (char *) "self",(char *) "flag", NULL
21978     };
21979
21980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
21981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21982     if (SWIG_arg_fail(1)) SWIG_fail;
21983     {
21984         arg2 = (bool)(SWIG_As_bool(obj1));
21985         if (SWIG_arg_fail(2)) SWIG_fail;
21986     }
21987     {
21988         PyThreadState* __tstate = wxPyBeginAllowThreads();
21989         (arg1)->EnableHelp(arg2);
21990
21991         wxPyEndAllowThreads(__tstate);
21992         if (PyErr_Occurred()) SWIG_fail;
21993     }
21994     Py_INCREF(Py_None); resultobj = Py_None;
21995     return resultobj;
21996     fail:
21997     return NULL;
21998 }
21999
22000
22001 static PyObject *_wrap_PageSetupDialogData_EnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22002     PyObject *resultobj;
22003     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22004     bool arg2 ;
22005     PyObject * obj0 = 0 ;
22006     PyObject * obj1 = 0 ;
22007     char *kwnames[] = {
22008         (char *) "self",(char *) "flag", NULL
22009     };
22010
22011     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableMargins",kwnames,&obj0,&obj1)) goto fail;
22012     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22013     if (SWIG_arg_fail(1)) SWIG_fail;
22014     {
22015         arg2 = (bool)(SWIG_As_bool(obj1));
22016         if (SWIG_arg_fail(2)) SWIG_fail;
22017     }
22018     {
22019         PyThreadState* __tstate = wxPyBeginAllowThreads();
22020         (arg1)->EnableMargins(arg2);
22021
22022         wxPyEndAllowThreads(__tstate);
22023         if (PyErr_Occurred()) SWIG_fail;
22024     }
22025     Py_INCREF(Py_None); resultobj = Py_None;
22026     return resultobj;
22027     fail:
22028     return NULL;
22029 }
22030
22031
22032 static PyObject *_wrap_PageSetupDialogData_EnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22033     PyObject *resultobj;
22034     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22035     bool arg2 ;
22036     PyObject * obj0 = 0 ;
22037     PyObject * obj1 = 0 ;
22038     char *kwnames[] = {
22039         (char *) "self",(char *) "flag", NULL
22040     };
22041
22042     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableOrientation",kwnames,&obj0,&obj1)) goto fail;
22043     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22044     if (SWIG_arg_fail(1)) SWIG_fail;
22045     {
22046         arg2 = (bool)(SWIG_As_bool(obj1));
22047         if (SWIG_arg_fail(2)) SWIG_fail;
22048     }
22049     {
22050         PyThreadState* __tstate = wxPyBeginAllowThreads();
22051         (arg1)->EnableOrientation(arg2);
22052
22053         wxPyEndAllowThreads(__tstate);
22054         if (PyErr_Occurred()) SWIG_fail;
22055     }
22056     Py_INCREF(Py_None); resultobj = Py_None;
22057     return resultobj;
22058     fail:
22059     return NULL;
22060 }
22061
22062
22063 static PyObject *_wrap_PageSetupDialogData_EnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22064     PyObject *resultobj;
22065     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22066     bool arg2 ;
22067     PyObject * obj0 = 0 ;
22068     PyObject * obj1 = 0 ;
22069     char *kwnames[] = {
22070         (char *) "self",(char *) "flag", NULL
22071     };
22072
22073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePaper",kwnames,&obj0,&obj1)) goto fail;
22074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22075     if (SWIG_arg_fail(1)) SWIG_fail;
22076     {
22077         arg2 = (bool)(SWIG_As_bool(obj1));
22078         if (SWIG_arg_fail(2)) SWIG_fail;
22079     }
22080     {
22081         PyThreadState* __tstate = wxPyBeginAllowThreads();
22082         (arg1)->EnablePaper(arg2);
22083
22084         wxPyEndAllowThreads(__tstate);
22085         if (PyErr_Occurred()) SWIG_fail;
22086     }
22087     Py_INCREF(Py_None); resultobj = Py_None;
22088     return resultobj;
22089     fail:
22090     return NULL;
22091 }
22092
22093
22094 static PyObject *_wrap_PageSetupDialogData_EnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22095     PyObject *resultobj;
22096     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22097     bool arg2 ;
22098     PyObject * obj0 = 0 ;
22099     PyObject * obj1 = 0 ;
22100     char *kwnames[] = {
22101         (char *) "self",(char *) "flag", NULL
22102     };
22103
22104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePrinter",kwnames,&obj0,&obj1)) goto fail;
22105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22106     if (SWIG_arg_fail(1)) SWIG_fail;
22107     {
22108         arg2 = (bool)(SWIG_As_bool(obj1));
22109         if (SWIG_arg_fail(2)) SWIG_fail;
22110     }
22111     {
22112         PyThreadState* __tstate = wxPyBeginAllowThreads();
22113         (arg1)->EnablePrinter(arg2);
22114
22115         wxPyEndAllowThreads(__tstate);
22116         if (PyErr_Occurred()) SWIG_fail;
22117     }
22118     Py_INCREF(Py_None); resultobj = Py_None;
22119     return resultobj;
22120     fail:
22121     return NULL;
22122 }
22123
22124
22125 static PyObject *_wrap_PageSetupDialogData_GetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22126     PyObject *resultobj;
22127     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22128     bool result;
22129     PyObject * obj0 = 0 ;
22130     char *kwnames[] = {
22131         (char *) "self", NULL
22132     };
22133
22134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultMinMargins",kwnames,&obj0)) goto fail;
22135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22136     if (SWIG_arg_fail(1)) SWIG_fail;
22137     {
22138         PyThreadState* __tstate = wxPyBeginAllowThreads();
22139         result = (bool)(arg1)->GetDefaultMinMargins();
22140
22141         wxPyEndAllowThreads(__tstate);
22142         if (PyErr_Occurred()) SWIG_fail;
22143     }
22144     {
22145         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22146     }
22147     return resultobj;
22148     fail:
22149     return NULL;
22150 }
22151
22152
22153 static PyObject *_wrap_PageSetupDialogData_GetEnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22154     PyObject *resultobj;
22155     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22156     bool result;
22157     PyObject * obj0 = 0 ;
22158     char *kwnames[] = {
22159         (char *) "self", NULL
22160     };
22161
22162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableMargins",kwnames,&obj0)) goto fail;
22163     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22164     if (SWIG_arg_fail(1)) SWIG_fail;
22165     {
22166         PyThreadState* __tstate = wxPyBeginAllowThreads();
22167         result = (bool)(arg1)->GetEnableMargins();
22168
22169         wxPyEndAllowThreads(__tstate);
22170         if (PyErr_Occurred()) SWIG_fail;
22171     }
22172     {
22173         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22174     }
22175     return resultobj;
22176     fail:
22177     return NULL;
22178 }
22179
22180
22181 static PyObject *_wrap_PageSetupDialogData_GetEnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22182     PyObject *resultobj;
22183     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22184     bool result;
22185     PyObject * obj0 = 0 ;
22186     char *kwnames[] = {
22187         (char *) "self", NULL
22188     };
22189
22190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableOrientation",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
22195         result = (bool)(arg1)->GetEnableOrientation();
22196
22197         wxPyEndAllowThreads(__tstate);
22198         if (PyErr_Occurred()) SWIG_fail;
22199     }
22200     {
22201         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22202     }
22203     return resultobj;
22204     fail:
22205     return NULL;
22206 }
22207
22208
22209 static PyObject *_wrap_PageSetupDialogData_GetEnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22210     PyObject *resultobj;
22211     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22212     bool result;
22213     PyObject * obj0 = 0 ;
22214     char *kwnames[] = {
22215         (char *) "self", NULL
22216     };
22217
22218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePaper",kwnames,&obj0)) goto fail;
22219     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22220     if (SWIG_arg_fail(1)) SWIG_fail;
22221     {
22222         PyThreadState* __tstate = wxPyBeginAllowThreads();
22223         result = (bool)(arg1)->GetEnablePaper();
22224
22225         wxPyEndAllowThreads(__tstate);
22226         if (PyErr_Occurred()) SWIG_fail;
22227     }
22228     {
22229         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22230     }
22231     return resultobj;
22232     fail:
22233     return NULL;
22234 }
22235
22236
22237 static PyObject *_wrap_PageSetupDialogData_GetEnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22238     PyObject *resultobj;
22239     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22240     bool result;
22241     PyObject * obj0 = 0 ;
22242     char *kwnames[] = {
22243         (char *) "self", NULL
22244     };
22245
22246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePrinter",kwnames,&obj0)) goto fail;
22247     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22248     if (SWIG_arg_fail(1)) SWIG_fail;
22249     {
22250         PyThreadState* __tstate = wxPyBeginAllowThreads();
22251         result = (bool)(arg1)->GetEnablePrinter();
22252
22253         wxPyEndAllowThreads(__tstate);
22254         if (PyErr_Occurred()) SWIG_fail;
22255     }
22256     {
22257         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22258     }
22259     return resultobj;
22260     fail:
22261     return NULL;
22262 }
22263
22264
22265 static PyObject *_wrap_PageSetupDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22266     PyObject *resultobj;
22267     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22268     bool result;
22269     PyObject * obj0 = 0 ;
22270     char *kwnames[] = {
22271         (char *) "self", NULL
22272     };
22273
22274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
22275     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22276     if (SWIG_arg_fail(1)) SWIG_fail;
22277     {
22278         PyThreadState* __tstate = wxPyBeginAllowThreads();
22279         result = (bool)(arg1)->GetEnableHelp();
22280
22281         wxPyEndAllowThreads(__tstate);
22282         if (PyErr_Occurred()) SWIG_fail;
22283     }
22284     {
22285         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22286     }
22287     return resultobj;
22288     fail:
22289     return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_PageSetupDialogData_GetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22294     PyObject *resultobj;
22295     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22296     bool result;
22297     PyObject * obj0 = 0 ;
22298     char *kwnames[] = {
22299         (char *) "self", NULL
22300     };
22301
22302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultInfo",kwnames,&obj0)) goto fail;
22303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22304     if (SWIG_arg_fail(1)) SWIG_fail;
22305     {
22306         PyThreadState* __tstate = wxPyBeginAllowThreads();
22307         result = (bool)(arg1)->GetDefaultInfo();
22308
22309         wxPyEndAllowThreads(__tstate);
22310         if (PyErr_Occurred()) SWIG_fail;
22311     }
22312     {
22313         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314     }
22315     return resultobj;
22316     fail:
22317     return NULL;
22318 }
22319
22320
22321 static PyObject *_wrap_PageSetupDialogData_GetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22322     PyObject *resultobj;
22323     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22324     wxPoint result;
22325     PyObject * obj0 = 0 ;
22326     char *kwnames[] = {
22327         (char *) "self", NULL
22328     };
22329
22330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginTopLeft",kwnames,&obj0)) goto fail;
22331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22332     if (SWIG_arg_fail(1)) SWIG_fail;
22333     {
22334         PyThreadState* __tstate = wxPyBeginAllowThreads();
22335         result = (arg1)->GetMarginTopLeft();
22336
22337         wxPyEndAllowThreads(__tstate);
22338         if (PyErr_Occurred()) SWIG_fail;
22339     }
22340     {
22341         wxPoint * resultptr;
22342         resultptr = new wxPoint((wxPoint &)(result));
22343         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22344     }
22345     return resultobj;
22346     fail:
22347     return NULL;
22348 }
22349
22350
22351 static PyObject *_wrap_PageSetupDialogData_GetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22352     PyObject *resultobj;
22353     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22354     wxPoint result;
22355     PyObject * obj0 = 0 ;
22356     char *kwnames[] = {
22357         (char *) "self", NULL
22358     };
22359
22360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginBottomRight",kwnames,&obj0)) goto fail;
22361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22362     if (SWIG_arg_fail(1)) SWIG_fail;
22363     {
22364         PyThreadState* __tstate = wxPyBeginAllowThreads();
22365         result = (arg1)->GetMarginBottomRight();
22366
22367         wxPyEndAllowThreads(__tstate);
22368         if (PyErr_Occurred()) SWIG_fail;
22369     }
22370     {
22371         wxPoint * resultptr;
22372         resultptr = new wxPoint((wxPoint &)(result));
22373         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22374     }
22375     return resultobj;
22376     fail:
22377     return NULL;
22378 }
22379
22380
22381 static PyObject *_wrap_PageSetupDialogData_GetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22382     PyObject *resultobj;
22383     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22384     wxPoint result;
22385     PyObject * obj0 = 0 ;
22386     char *kwnames[] = {
22387         (char *) "self", NULL
22388     };
22389
22390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginTopLeft",kwnames,&obj0)) goto fail;
22391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22392     if (SWIG_arg_fail(1)) SWIG_fail;
22393     {
22394         PyThreadState* __tstate = wxPyBeginAllowThreads();
22395         result = (arg1)->GetMinMarginTopLeft();
22396
22397         wxPyEndAllowThreads(__tstate);
22398         if (PyErr_Occurred()) SWIG_fail;
22399     }
22400     {
22401         wxPoint * resultptr;
22402         resultptr = new wxPoint((wxPoint &)(result));
22403         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22404     }
22405     return resultobj;
22406     fail:
22407     return NULL;
22408 }
22409
22410
22411 static PyObject *_wrap_PageSetupDialogData_GetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22412     PyObject *resultobj;
22413     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22414     wxPoint result;
22415     PyObject * obj0 = 0 ;
22416     char *kwnames[] = {
22417         (char *) "self", NULL
22418     };
22419
22420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginBottomRight",kwnames,&obj0)) goto fail;
22421     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22422     if (SWIG_arg_fail(1)) SWIG_fail;
22423     {
22424         PyThreadState* __tstate = wxPyBeginAllowThreads();
22425         result = (arg1)->GetMinMarginBottomRight();
22426
22427         wxPyEndAllowThreads(__tstate);
22428         if (PyErr_Occurred()) SWIG_fail;
22429     }
22430     {
22431         wxPoint * resultptr;
22432         resultptr = new wxPoint((wxPoint &)(result));
22433         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22434     }
22435     return resultobj;
22436     fail:
22437     return NULL;
22438 }
22439
22440
22441 static PyObject *_wrap_PageSetupDialogData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22442     PyObject *resultobj;
22443     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22444     wxPaperSize result;
22445     PyObject * obj0 = 0 ;
22446     char *kwnames[] = {
22447         (char *) "self", NULL
22448     };
22449
22450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperId",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 = (wxPaperSize)(arg1)->GetPaperId();
22456
22457         wxPyEndAllowThreads(__tstate);
22458         if (PyErr_Occurred()) SWIG_fail;
22459     }
22460     resultobj = SWIG_From_int((result));
22461     return resultobj;
22462     fail:
22463     return NULL;
22464 }
22465
22466
22467 static PyObject *_wrap_PageSetupDialogData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22468     PyObject *resultobj;
22469     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22470     wxSize result;
22471     PyObject * obj0 = 0 ;
22472     char *kwnames[] = {
22473         (char *) "self", NULL
22474     };
22475
22476     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperSize",kwnames,&obj0)) goto fail;
22477     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22478     if (SWIG_arg_fail(1)) SWIG_fail;
22479     {
22480         PyThreadState* __tstate = wxPyBeginAllowThreads();
22481         result = (arg1)->GetPaperSize();
22482
22483         wxPyEndAllowThreads(__tstate);
22484         if (PyErr_Occurred()) SWIG_fail;
22485     }
22486     {
22487         wxSize * resultptr;
22488         resultptr = new wxSize((wxSize &)(result));
22489         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
22490     }
22491     return resultobj;
22492     fail:
22493     return NULL;
22494 }
22495
22496
22497 static PyObject *_wrap_PageSetupDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22498     PyObject *resultobj;
22499     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22500     wxPrintData *result;
22501     PyObject * obj0 = 0 ;
22502     char *kwnames[] = {
22503         (char *) "self", NULL
22504     };
22505
22506     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPrintData",kwnames,&obj0)) goto fail;
22507     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22508     if (SWIG_arg_fail(1)) SWIG_fail;
22509     {
22510         PyThreadState* __tstate = wxPyBeginAllowThreads();
22511         {
22512             wxPrintData &_result_ref = (arg1)->GetPrintData();
22513             result = (wxPrintData *) &_result_ref;
22514         }
22515
22516         wxPyEndAllowThreads(__tstate);
22517         if (PyErr_Occurred()) SWIG_fail;
22518     }
22519     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
22520     return resultobj;
22521     fail:
22522     return NULL;
22523 }
22524
22525
22526 static PyObject *_wrap_PageSetupDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
22527     PyObject *resultobj;
22528     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22529     bool result;
22530     PyObject * obj0 = 0 ;
22531     char *kwnames[] = {
22532         (char *) "self", NULL
22533     };
22534
22535     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_Ok",kwnames,&obj0)) goto fail;
22536     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22537     if (SWIG_arg_fail(1)) SWIG_fail;
22538     {
22539         PyThreadState* __tstate = wxPyBeginAllowThreads();
22540         result = (bool)(arg1)->Ok();
22541
22542         wxPyEndAllowThreads(__tstate);
22543         if (PyErr_Occurred()) SWIG_fail;
22544     }
22545     {
22546         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22547     }
22548     return resultobj;
22549     fail:
22550     return NULL;
22551 }
22552
22553
22554 static PyObject *_wrap_PageSetupDialogData_SetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22555     PyObject *resultobj;
22556     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22557     bool arg2 ;
22558     PyObject * obj0 = 0 ;
22559     PyObject * obj1 = 0 ;
22560     char *kwnames[] = {
22561         (char *) "self",(char *) "flag", NULL
22562     };
22563
22564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultInfo",kwnames,&obj0,&obj1)) goto fail;
22565     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22566     if (SWIG_arg_fail(1)) SWIG_fail;
22567     {
22568         arg2 = (bool)(SWIG_As_bool(obj1));
22569         if (SWIG_arg_fail(2)) SWIG_fail;
22570     }
22571     {
22572         PyThreadState* __tstate = wxPyBeginAllowThreads();
22573         (arg1)->SetDefaultInfo(arg2);
22574
22575         wxPyEndAllowThreads(__tstate);
22576         if (PyErr_Occurred()) SWIG_fail;
22577     }
22578     Py_INCREF(Py_None); resultobj = Py_None;
22579     return resultobj;
22580     fail:
22581     return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_PageSetupDialogData_SetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22586     PyObject *resultobj;
22587     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22588     bool arg2 ;
22589     PyObject * obj0 = 0 ;
22590     PyObject * obj1 = 0 ;
22591     char *kwnames[] = {
22592         (char *) "self",(char *) "flag", NULL
22593     };
22594
22595     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultMinMargins",kwnames,&obj0,&obj1)) goto fail;
22596     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22597     if (SWIG_arg_fail(1)) SWIG_fail;
22598     {
22599         arg2 = (bool)(SWIG_As_bool(obj1));
22600         if (SWIG_arg_fail(2)) SWIG_fail;
22601     }
22602     {
22603         PyThreadState* __tstate = wxPyBeginAllowThreads();
22604         (arg1)->SetDefaultMinMargins(arg2);
22605
22606         wxPyEndAllowThreads(__tstate);
22607         if (PyErr_Occurred()) SWIG_fail;
22608     }
22609     Py_INCREF(Py_None); resultobj = Py_None;
22610     return resultobj;
22611     fail:
22612     return NULL;
22613 }
22614
22615
22616 static PyObject *_wrap_PageSetupDialogData_SetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22617     PyObject *resultobj;
22618     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22619     wxPoint *arg2 = 0 ;
22620     wxPoint temp2 ;
22621     PyObject * obj0 = 0 ;
22622     PyObject * obj1 = 0 ;
22623     char *kwnames[] = {
22624         (char *) "self",(char *) "pt", NULL
22625     };
22626
22627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22629     if (SWIG_arg_fail(1)) SWIG_fail;
22630     {
22631         arg2 = &temp2;
22632         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22633     }
22634     {
22635         PyThreadState* __tstate = wxPyBeginAllowThreads();
22636         (arg1)->SetMarginTopLeft((wxPoint const &)*arg2);
22637
22638         wxPyEndAllowThreads(__tstate);
22639         if (PyErr_Occurred()) SWIG_fail;
22640     }
22641     Py_INCREF(Py_None); resultobj = Py_None;
22642     return resultobj;
22643     fail:
22644     return NULL;
22645 }
22646
22647
22648 static PyObject *_wrap_PageSetupDialogData_SetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22649     PyObject *resultobj;
22650     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22651     wxPoint *arg2 = 0 ;
22652     wxPoint temp2 ;
22653     PyObject * obj0 = 0 ;
22654     PyObject * obj1 = 0 ;
22655     char *kwnames[] = {
22656         (char *) "self",(char *) "pt", NULL
22657     };
22658
22659     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22660     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22661     if (SWIG_arg_fail(1)) SWIG_fail;
22662     {
22663         arg2 = &temp2;
22664         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22665     }
22666     {
22667         PyThreadState* __tstate = wxPyBeginAllowThreads();
22668         (arg1)->SetMarginBottomRight((wxPoint const &)*arg2);
22669
22670         wxPyEndAllowThreads(__tstate);
22671         if (PyErr_Occurred()) SWIG_fail;
22672     }
22673     Py_INCREF(Py_None); resultobj = Py_None;
22674     return resultobj;
22675     fail:
22676     return NULL;
22677 }
22678
22679
22680 static PyObject *_wrap_PageSetupDialogData_SetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22681     PyObject *resultobj;
22682     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22683     wxPoint *arg2 = 0 ;
22684     wxPoint temp2 ;
22685     PyObject * obj0 = 0 ;
22686     PyObject * obj1 = 0 ;
22687     char *kwnames[] = {
22688         (char *) "self",(char *) "pt", NULL
22689     };
22690
22691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22692     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22693     if (SWIG_arg_fail(1)) SWIG_fail;
22694     {
22695         arg2 = &temp2;
22696         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22697     }
22698     {
22699         PyThreadState* __tstate = wxPyBeginAllowThreads();
22700         (arg1)->SetMinMarginTopLeft((wxPoint const &)*arg2);
22701
22702         wxPyEndAllowThreads(__tstate);
22703         if (PyErr_Occurred()) SWIG_fail;
22704     }
22705     Py_INCREF(Py_None); resultobj = Py_None;
22706     return resultobj;
22707     fail:
22708     return NULL;
22709 }
22710
22711
22712 static PyObject *_wrap_PageSetupDialogData_SetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22713     PyObject *resultobj;
22714     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22715     wxPoint *arg2 = 0 ;
22716     wxPoint temp2 ;
22717     PyObject * obj0 = 0 ;
22718     PyObject * obj1 = 0 ;
22719     char *kwnames[] = {
22720         (char *) "self",(char *) "pt", NULL
22721     };
22722
22723     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22724     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22725     if (SWIG_arg_fail(1)) SWIG_fail;
22726     {
22727         arg2 = &temp2;
22728         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22729     }
22730     {
22731         PyThreadState* __tstate = wxPyBeginAllowThreads();
22732         (arg1)->SetMinMarginBottomRight((wxPoint const &)*arg2);
22733
22734         wxPyEndAllowThreads(__tstate);
22735         if (PyErr_Occurred()) SWIG_fail;
22736     }
22737     Py_INCREF(Py_None); resultobj = Py_None;
22738     return resultobj;
22739     fail:
22740     return NULL;
22741 }
22742
22743
22744 static PyObject *_wrap_PageSetupDialogData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22745     PyObject *resultobj;
22746     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22747     wxPaperSize arg2 ;
22748     PyObject * obj0 = 0 ;
22749     PyObject * obj1 = 0 ;
22750     char *kwnames[] = {
22751         (char *) "self",(char *) "id", NULL
22752     };
22753
22754     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
22755     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22756     if (SWIG_arg_fail(1)) SWIG_fail;
22757     {
22758         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
22759         if (SWIG_arg_fail(2)) SWIG_fail;
22760     }
22761     {
22762         PyThreadState* __tstate = wxPyBeginAllowThreads();
22763         (arg1)->SetPaperId((wxPaperSize )arg2);
22764
22765         wxPyEndAllowThreads(__tstate);
22766         if (PyErr_Occurred()) SWIG_fail;
22767     }
22768     Py_INCREF(Py_None); resultobj = Py_None;
22769     return resultobj;
22770     fail:
22771     return NULL;
22772 }
22773
22774
22775 static PyObject *_wrap_PageSetupDialogData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22776     PyObject *resultobj;
22777     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22778     wxSize *arg2 = 0 ;
22779     wxSize temp2 ;
22780     PyObject * obj0 = 0 ;
22781     PyObject * obj1 = 0 ;
22782     char *kwnames[] = {
22783         (char *) "self",(char *) "size", NULL
22784     };
22785
22786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
22787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22788     if (SWIG_arg_fail(1)) SWIG_fail;
22789     {
22790         arg2 = &temp2;
22791         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
22792     }
22793     {
22794         PyThreadState* __tstate = wxPyBeginAllowThreads();
22795         (arg1)->SetPaperSize((wxSize const &)*arg2);
22796
22797         wxPyEndAllowThreads(__tstate);
22798         if (PyErr_Occurred()) SWIG_fail;
22799     }
22800     Py_INCREF(Py_None); resultobj = Py_None;
22801     return resultobj;
22802     fail:
22803     return NULL;
22804 }
22805
22806
22807 static PyObject *_wrap_PageSetupDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22808     PyObject *resultobj;
22809     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22810     wxPrintData *arg2 = 0 ;
22811     PyObject * obj0 = 0 ;
22812     PyObject * obj1 = 0 ;
22813     char *kwnames[] = {
22814         (char *) "self",(char *) "printData", NULL
22815     };
22816
22817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
22818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22819     if (SWIG_arg_fail(1)) SWIG_fail;
22820     {
22821         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22822         if (SWIG_arg_fail(2)) SWIG_fail;
22823         if (arg2 == NULL) {
22824             SWIG_null_ref("wxPrintData");
22825         }
22826         if (SWIG_arg_fail(2)) SWIG_fail;
22827     }
22828     {
22829         PyThreadState* __tstate = wxPyBeginAllowThreads();
22830         (arg1)->SetPrintData((wxPrintData const &)*arg2);
22831
22832         wxPyEndAllowThreads(__tstate);
22833         if (PyErr_Occurred()) SWIG_fail;
22834     }
22835     Py_INCREF(Py_None); resultobj = Py_None;
22836     return resultobj;
22837     fail:
22838     return NULL;
22839 }
22840
22841
22842 static PyObject *_wrap_PageSetupDialogData_CalculateIdFromPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22843     PyObject *resultobj;
22844     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22845     PyObject * obj0 = 0 ;
22846     char *kwnames[] = {
22847         (char *) "self", NULL
22848     };
22849
22850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculateIdFromPaperSize",kwnames,&obj0)) goto fail;
22851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22852     if (SWIG_arg_fail(1)) SWIG_fail;
22853     {
22854         PyThreadState* __tstate = wxPyBeginAllowThreads();
22855         (arg1)->CalculateIdFromPaperSize();
22856
22857         wxPyEndAllowThreads(__tstate);
22858         if (PyErr_Occurred()) SWIG_fail;
22859     }
22860     Py_INCREF(Py_None); resultobj = Py_None;
22861     return resultobj;
22862     fail:
22863     return NULL;
22864 }
22865
22866
22867 static PyObject *_wrap_PageSetupDialogData_CalculatePaperSizeFromId(PyObject *, PyObject *args, PyObject *kwargs) {
22868     PyObject *resultobj;
22869     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22870     PyObject * obj0 = 0 ;
22871     char *kwnames[] = {
22872         (char *) "self", NULL
22873     };
22874
22875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculatePaperSizeFromId",kwnames,&obj0)) goto fail;
22876     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22877     if (SWIG_arg_fail(1)) SWIG_fail;
22878     {
22879         PyThreadState* __tstate = wxPyBeginAllowThreads();
22880         (arg1)->CalculatePaperSizeFromId();
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 * PageSetupDialogData_swigregister(PyObject *, PyObject *args) {
22893     PyObject *obj;
22894     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22895     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialogData, obj);
22896     Py_INCREF(obj);
22897     return Py_BuildValue((char *)"");
22898 }
22899 static PyObject *_wrap_new_PageSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
22900     PyObject *resultobj;
22901     wxWindow *arg1 = (wxWindow *) 0 ;
22902     wxPageSetupDialogData *arg2 = (wxPageSetupDialogData *) NULL ;
22903     wxPageSetupDialog *result;
22904     PyObject * obj0 = 0 ;
22905     PyObject * obj1 = 0 ;
22906     char *kwnames[] = {
22907         (char *) "parent",(char *) "data", NULL
22908     };
22909
22910     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PageSetupDialog",kwnames,&obj0,&obj1)) goto fail;
22911     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22912     if (SWIG_arg_fail(1)) SWIG_fail;
22913     if (obj1) {
22914         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22915         if (SWIG_arg_fail(2)) SWIG_fail;
22916     }
22917     {
22918         if (!wxPyCheckForApp()) SWIG_fail;
22919         PyThreadState* __tstate = wxPyBeginAllowThreads();
22920         result = (wxPageSetupDialog *)new wxPageSetupDialog(arg1,arg2);
22921
22922         wxPyEndAllowThreads(__tstate);
22923         if (PyErr_Occurred()) SWIG_fail;
22924     }
22925     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialog, 1);
22926     return resultobj;
22927     fail:
22928     return NULL;
22929 }
22930
22931
22932 static PyObject *_wrap_PageSetupDialog_GetPageSetupData(PyObject *, PyObject *args, PyObject *kwargs) {
22933     PyObject *resultobj;
22934     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22935     wxPageSetupDialogData *result;
22936     PyObject * obj0 = 0 ;
22937     char *kwnames[] = {
22938         (char *) "self", NULL
22939     };
22940
22941     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupData",kwnames,&obj0)) goto fail;
22942     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22943     if (SWIG_arg_fail(1)) SWIG_fail;
22944     {
22945         PyThreadState* __tstate = wxPyBeginAllowThreads();
22946         {
22947             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupData();
22948             result = (wxPageSetupDialogData *) &_result_ref;
22949         }
22950
22951         wxPyEndAllowThreads(__tstate);
22952         if (PyErr_Occurred()) SWIG_fail;
22953     }
22954     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22955     return resultobj;
22956     fail:
22957     return NULL;
22958 }
22959
22960
22961 static PyObject *_wrap_PageSetupDialog_GetPageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
22962     PyObject *resultobj;
22963     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22964     wxPageSetupDialogData *result;
22965     PyObject * obj0 = 0 ;
22966     char *kwnames[] = {
22967         (char *) "self", NULL
22968     };
22969
22970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupDialogData",kwnames,&obj0)) goto fail;
22971     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22972     if (SWIG_arg_fail(1)) SWIG_fail;
22973     {
22974         PyThreadState* __tstate = wxPyBeginAllowThreads();
22975         {
22976             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupDialogData();
22977             result = (wxPageSetupDialogData *) &_result_ref;
22978         }
22979
22980         wxPyEndAllowThreads(__tstate);
22981         if (PyErr_Occurred()) SWIG_fail;
22982     }
22983     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22984     return resultobj;
22985     fail:
22986     return NULL;
22987 }
22988
22989
22990 static PyObject *_wrap_PageSetupDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
22991     PyObject *resultobj;
22992     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22993     int result;
22994     PyObject * obj0 = 0 ;
22995     char *kwnames[] = {
22996         (char *) "self", NULL
22997     };
22998
22999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_ShowModal",kwnames,&obj0)) goto fail;
23000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23001     if (SWIG_arg_fail(1)) SWIG_fail;
23002     {
23003         PyThreadState* __tstate = wxPyBeginAllowThreads();
23004         result = (int)(arg1)->ShowModal();
23005
23006         wxPyEndAllowThreads(__tstate);
23007         if (PyErr_Occurred()) SWIG_fail;
23008     }
23009     {
23010         resultobj = SWIG_From_int((int)(result));
23011     }
23012     return resultobj;
23013     fail:
23014     return NULL;
23015 }
23016
23017
23018 static PyObject * PageSetupDialog_swigregister(PyObject *, PyObject *args) {
23019     PyObject *obj;
23020     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23021     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialog, obj);
23022     Py_INCREF(obj);
23023     return Py_BuildValue((char *)"");
23024 }
23025 static PyObject *_wrap_new_PrintDialogData__SWIG_0(PyObject *, PyObject *args) {
23026     PyObject *resultobj;
23027     wxPrintDialogData *result;
23028
23029     if(!PyArg_ParseTuple(args,(char *)":new_PrintDialogData")) goto fail;
23030     {
23031         PyThreadState* __tstate = wxPyBeginAllowThreads();
23032         result = (wxPrintDialogData *)new wxPrintDialogData();
23033
23034         wxPyEndAllowThreads(__tstate);
23035         if (PyErr_Occurred()) SWIG_fail;
23036     }
23037     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23038     return resultobj;
23039     fail:
23040     return NULL;
23041 }
23042
23043
23044 static PyObject *_wrap_new_PrintDialogData__SWIG_1(PyObject *, PyObject *args) {
23045     PyObject *resultobj;
23046     wxPrintData *arg1 = 0 ;
23047     wxPrintDialogData *result;
23048     PyObject * obj0 = 0 ;
23049
23050     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23051     {
23052         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
23053         if (SWIG_arg_fail(1)) SWIG_fail;
23054         if (arg1 == NULL) {
23055             SWIG_null_ref("wxPrintData");
23056         }
23057         if (SWIG_arg_fail(1)) SWIG_fail;
23058     }
23059     {
23060         PyThreadState* __tstate = wxPyBeginAllowThreads();
23061         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintData const &)*arg1);
23062
23063         wxPyEndAllowThreads(__tstate);
23064         if (PyErr_Occurred()) SWIG_fail;
23065     }
23066     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23067     return resultobj;
23068     fail:
23069     return NULL;
23070 }
23071
23072
23073 static PyObject *_wrap_new_PrintDialogData__SWIG_2(PyObject *, PyObject *args) {
23074     PyObject *resultobj;
23075     wxPrintDialogData *arg1 = 0 ;
23076     wxPrintDialogData *result;
23077     PyObject * obj0 = 0 ;
23078
23079     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23080     {
23081         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23082         if (SWIG_arg_fail(1)) SWIG_fail;
23083         if (arg1 == NULL) {
23084             SWIG_null_ref("wxPrintDialogData");
23085         }
23086         if (SWIG_arg_fail(1)) SWIG_fail;
23087     }
23088     {
23089         PyThreadState* __tstate = wxPyBeginAllowThreads();
23090         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintDialogData const &)*arg1);
23091
23092         wxPyEndAllowThreads(__tstate);
23093         if (PyErr_Occurred()) SWIG_fail;
23094     }
23095     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23096     return resultobj;
23097     fail:
23098     return NULL;
23099 }
23100
23101
23102 static PyObject *_wrap_new_PrintDialogData(PyObject *self, PyObject *args) {
23103     int argc;
23104     PyObject *argv[2];
23105     int ii;
23106
23107     argc = PyObject_Length(args);
23108     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23109         argv[ii] = PyTuple_GetItem(args,ii);
23110     }
23111     if (argc == 0) {
23112         return _wrap_new_PrintDialogData__SWIG_0(self,args);
23113     }
23114     if (argc == 1) {
23115         int _v;
23116         {
23117             void *ptr = 0;
23118             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
23119                 _v = 0;
23120                 PyErr_Clear();
23121             } else {
23122                 _v = (ptr != 0);
23123             }
23124         }
23125         if (_v) {
23126             return _wrap_new_PrintDialogData__SWIG_1(self,args);
23127         }
23128     }
23129     if (argc == 1) {
23130         int _v;
23131         {
23132             void *ptr = 0;
23133             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
23134                 _v = 0;
23135                 PyErr_Clear();
23136             } else {
23137                 _v = (ptr != 0);
23138             }
23139         }
23140         if (_v) {
23141             return _wrap_new_PrintDialogData__SWIG_2(self,args);
23142         }
23143     }
23144
23145     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintDialogData'");
23146     return NULL;
23147 }
23148
23149
23150 static PyObject *_wrap_delete_PrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23151     PyObject *resultobj;
23152     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23153     PyObject * obj0 = 0 ;
23154     char *kwnames[] = {
23155         (char *) "self", NULL
23156     };
23157
23158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintDialogData",kwnames,&obj0)) goto fail;
23159     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23160     if (SWIG_arg_fail(1)) SWIG_fail;
23161     {
23162         PyThreadState* __tstate = wxPyBeginAllowThreads();
23163         delete arg1;
23164
23165         wxPyEndAllowThreads(__tstate);
23166         if (PyErr_Occurred()) SWIG_fail;
23167     }
23168     Py_INCREF(Py_None); resultobj = Py_None;
23169     return resultobj;
23170     fail:
23171     return NULL;
23172 }
23173
23174
23175 static PyObject *_wrap_PrintDialogData_GetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23176     PyObject *resultobj;
23177     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23178     int result;
23179     PyObject * obj0 = 0 ;
23180     char *kwnames[] = {
23181         (char *) "self", NULL
23182     };
23183
23184     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetFromPage",kwnames,&obj0)) goto fail;
23185     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23186     if (SWIG_arg_fail(1)) SWIG_fail;
23187     {
23188         PyThreadState* __tstate = wxPyBeginAllowThreads();
23189         result = (int)((wxPrintDialogData const *)arg1)->GetFromPage();
23190
23191         wxPyEndAllowThreads(__tstate);
23192         if (PyErr_Occurred()) SWIG_fail;
23193     }
23194     {
23195         resultobj = SWIG_From_int((int)(result));
23196     }
23197     return resultobj;
23198     fail:
23199     return NULL;
23200 }
23201
23202
23203 static PyObject *_wrap_PrintDialogData_GetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23204     PyObject *resultobj;
23205     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23206     int result;
23207     PyObject * obj0 = 0 ;
23208     char *kwnames[] = {
23209         (char *) "self", NULL
23210     };
23211
23212     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetToPage",kwnames,&obj0)) goto fail;
23213     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23214     if (SWIG_arg_fail(1)) SWIG_fail;
23215     {
23216         PyThreadState* __tstate = wxPyBeginAllowThreads();
23217         result = (int)((wxPrintDialogData const *)arg1)->GetToPage();
23218
23219         wxPyEndAllowThreads(__tstate);
23220         if (PyErr_Occurred()) SWIG_fail;
23221     }
23222     {
23223         resultobj = SWIG_From_int((int)(result));
23224     }
23225     return resultobj;
23226     fail:
23227     return NULL;
23228 }
23229
23230
23231 static PyObject *_wrap_PrintDialogData_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23232     PyObject *resultobj;
23233     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23234     int result;
23235     PyObject * obj0 = 0 ;
23236     char *kwnames[] = {
23237         (char *) "self", NULL
23238     };
23239
23240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMinPage",kwnames,&obj0)) goto fail;
23241     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23242     if (SWIG_arg_fail(1)) SWIG_fail;
23243     {
23244         PyThreadState* __tstate = wxPyBeginAllowThreads();
23245         result = (int)((wxPrintDialogData const *)arg1)->GetMinPage();
23246
23247         wxPyEndAllowThreads(__tstate);
23248         if (PyErr_Occurred()) SWIG_fail;
23249     }
23250     {
23251         resultobj = SWIG_From_int((int)(result));
23252     }
23253     return resultobj;
23254     fail:
23255     return NULL;
23256 }
23257
23258
23259 static PyObject *_wrap_PrintDialogData_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23260     PyObject *resultobj;
23261     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23262     int result;
23263     PyObject * obj0 = 0 ;
23264     char *kwnames[] = {
23265         (char *) "self", NULL
23266     };
23267
23268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMaxPage",kwnames,&obj0)) goto fail;
23269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23270     if (SWIG_arg_fail(1)) SWIG_fail;
23271     {
23272         PyThreadState* __tstate = wxPyBeginAllowThreads();
23273         result = (int)((wxPrintDialogData const *)arg1)->GetMaxPage();
23274
23275         wxPyEndAllowThreads(__tstate);
23276         if (PyErr_Occurred()) SWIG_fail;
23277     }
23278     {
23279         resultobj = SWIG_From_int((int)(result));
23280     }
23281     return resultobj;
23282     fail:
23283     return NULL;
23284 }
23285
23286
23287 static PyObject *_wrap_PrintDialogData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23288     PyObject *resultobj;
23289     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23290     int result;
23291     PyObject * obj0 = 0 ;
23292     char *kwnames[] = {
23293         (char *) "self", NULL
23294     };
23295
23296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetNoCopies",kwnames,&obj0)) goto fail;
23297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23298     if (SWIG_arg_fail(1)) SWIG_fail;
23299     {
23300         PyThreadState* __tstate = wxPyBeginAllowThreads();
23301         result = (int)((wxPrintDialogData const *)arg1)->GetNoCopies();
23302
23303         wxPyEndAllowThreads(__tstate);
23304         if (PyErr_Occurred()) SWIG_fail;
23305     }
23306     {
23307         resultobj = SWIG_From_int((int)(result));
23308     }
23309     return resultobj;
23310     fail:
23311     return NULL;
23312 }
23313
23314
23315 static PyObject *_wrap_PrintDialogData_GetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23316     PyObject *resultobj;
23317     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23318     bool result;
23319     PyObject * obj0 = 0 ;
23320     char *kwnames[] = {
23321         (char *) "self", NULL
23322     };
23323
23324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetAllPages",kwnames,&obj0)) goto fail;
23325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23326     if (SWIG_arg_fail(1)) SWIG_fail;
23327     {
23328         PyThreadState* __tstate = wxPyBeginAllowThreads();
23329         result = (bool)((wxPrintDialogData const *)arg1)->GetAllPages();
23330
23331         wxPyEndAllowThreads(__tstate);
23332         if (PyErr_Occurred()) SWIG_fail;
23333     }
23334     {
23335         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23336     }
23337     return resultobj;
23338     fail:
23339     return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PrintDialogData_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23344     PyObject *resultobj;
23345     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23346     bool result;
23347     PyObject * obj0 = 0 ;
23348     char *kwnames[] = {
23349         (char *) "self", NULL
23350     };
23351
23352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSelection",kwnames,&obj0)) goto fail;
23353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23354     if (SWIG_arg_fail(1)) SWIG_fail;
23355     {
23356         PyThreadState* __tstate = wxPyBeginAllowThreads();
23357         result = (bool)((wxPrintDialogData const *)arg1)->GetSelection();
23358
23359         wxPyEndAllowThreads(__tstate);
23360         if (PyErr_Occurred()) SWIG_fail;
23361     }
23362     {
23363         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23364     }
23365     return resultobj;
23366     fail:
23367     return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PrintDialogData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23372     PyObject *resultobj;
23373     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23374     bool result;
23375     PyObject * obj0 = 0 ;
23376     char *kwnames[] = {
23377         (char *) "self", NULL
23378     };
23379
23380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetCollate",kwnames,&obj0)) goto fail;
23381     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23382     if (SWIG_arg_fail(1)) SWIG_fail;
23383     {
23384         PyThreadState* __tstate = wxPyBeginAllowThreads();
23385         result = (bool)((wxPrintDialogData const *)arg1)->GetCollate();
23386
23387         wxPyEndAllowThreads(__tstate);
23388         if (PyErr_Occurred()) SWIG_fail;
23389     }
23390     {
23391         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23392     }
23393     return resultobj;
23394     fail:
23395     return NULL;
23396 }
23397
23398
23399 static PyObject *_wrap_PrintDialogData_GetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23400     PyObject *resultobj;
23401     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23402     bool result;
23403     PyObject * obj0 = 0 ;
23404     char *kwnames[] = {
23405         (char *) "self", NULL
23406     };
23407
23408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintToFile",kwnames,&obj0)) goto fail;
23409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23410     if (SWIG_arg_fail(1)) SWIG_fail;
23411     {
23412         PyThreadState* __tstate = wxPyBeginAllowThreads();
23413         result = (bool)((wxPrintDialogData const *)arg1)->GetPrintToFile();
23414
23415         wxPyEndAllowThreads(__tstate);
23416         if (PyErr_Occurred()) SWIG_fail;
23417     }
23418     {
23419         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23420     }
23421     return resultobj;
23422     fail:
23423     return NULL;
23424 }
23425
23426
23427 static PyObject *_wrap_PrintDialogData_GetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23428     PyObject *resultobj;
23429     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23430     bool result;
23431     PyObject * obj0 = 0 ;
23432     char *kwnames[] = {
23433         (char *) "self", NULL
23434     };
23435
23436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSetupDialog",kwnames,&obj0)) goto fail;
23437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23438     if (SWIG_arg_fail(1)) SWIG_fail;
23439     {
23440         PyThreadState* __tstate = wxPyBeginAllowThreads();
23441         result = (bool)((wxPrintDialogData const *)arg1)->GetSetupDialog();
23442
23443         wxPyEndAllowThreads(__tstate);
23444         if (PyErr_Occurred()) SWIG_fail;
23445     }
23446     {
23447         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23448     }
23449     return resultobj;
23450     fail:
23451     return NULL;
23452 }
23453
23454
23455 static PyObject *_wrap_PrintDialogData_SetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23456     PyObject *resultobj;
23457     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23458     bool arg2 ;
23459     PyObject * obj0 = 0 ;
23460     PyObject * obj1 = 0 ;
23461     char *kwnames[] = {
23462         (char *) "self",(char *) "flag", NULL
23463     };
23464
23465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23466     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23467     if (SWIG_arg_fail(1)) SWIG_fail;
23468     {
23469         arg2 = (bool)(SWIG_As_bool(obj1));
23470         if (SWIG_arg_fail(2)) SWIG_fail;
23471     }
23472     {
23473         PyThreadState* __tstate = wxPyBeginAllowThreads();
23474         (arg1)->SetSetupDialog(arg2);
23475
23476         wxPyEndAllowThreads(__tstate);
23477         if (PyErr_Occurred()) SWIG_fail;
23478     }
23479     Py_INCREF(Py_None); resultobj = Py_None;
23480     return resultobj;
23481     fail:
23482     return NULL;
23483 }
23484
23485
23486 static PyObject *_wrap_PrintDialogData_SetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23487     PyObject *resultobj;
23488     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23489     int arg2 ;
23490     PyObject * obj0 = 0 ;
23491     PyObject * obj1 = 0 ;
23492     char *kwnames[] = {
23493         (char *) "self",(char *) "v", NULL
23494     };
23495
23496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetFromPage",kwnames,&obj0,&obj1)) goto fail;
23497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23498     if (SWIG_arg_fail(1)) SWIG_fail;
23499     {
23500         arg2 = (int)(SWIG_As_int(obj1));
23501         if (SWIG_arg_fail(2)) SWIG_fail;
23502     }
23503     {
23504         PyThreadState* __tstate = wxPyBeginAllowThreads();
23505         (arg1)->SetFromPage(arg2);
23506
23507         wxPyEndAllowThreads(__tstate);
23508         if (PyErr_Occurred()) SWIG_fail;
23509     }
23510     Py_INCREF(Py_None); resultobj = Py_None;
23511     return resultobj;
23512     fail:
23513     return NULL;
23514 }
23515
23516
23517 static PyObject *_wrap_PrintDialogData_SetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23518     PyObject *resultobj;
23519     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23520     int arg2 ;
23521     PyObject * obj0 = 0 ;
23522     PyObject * obj1 = 0 ;
23523     char *kwnames[] = {
23524         (char *) "self",(char *) "v", NULL
23525     };
23526
23527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetToPage",kwnames,&obj0,&obj1)) goto fail;
23528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23529     if (SWIG_arg_fail(1)) SWIG_fail;
23530     {
23531         arg2 = (int)(SWIG_As_int(obj1));
23532         if (SWIG_arg_fail(2)) SWIG_fail;
23533     }
23534     {
23535         PyThreadState* __tstate = wxPyBeginAllowThreads();
23536         (arg1)->SetToPage(arg2);
23537
23538         wxPyEndAllowThreads(__tstate);
23539         if (PyErr_Occurred()) SWIG_fail;
23540     }
23541     Py_INCREF(Py_None); resultobj = Py_None;
23542     return resultobj;
23543     fail:
23544     return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PrintDialogData_SetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23549     PyObject *resultobj;
23550     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23551     int arg2 ;
23552     PyObject * obj0 = 0 ;
23553     PyObject * obj1 = 0 ;
23554     char *kwnames[] = {
23555         (char *) "self",(char *) "v", NULL
23556     };
23557
23558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMinPage",kwnames,&obj0,&obj1)) goto fail;
23559     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23560     if (SWIG_arg_fail(1)) SWIG_fail;
23561     {
23562         arg2 = (int)(SWIG_As_int(obj1));
23563         if (SWIG_arg_fail(2)) SWIG_fail;
23564     }
23565     {
23566         PyThreadState* __tstate = wxPyBeginAllowThreads();
23567         (arg1)->SetMinPage(arg2);
23568
23569         wxPyEndAllowThreads(__tstate);
23570         if (PyErr_Occurred()) SWIG_fail;
23571     }
23572     Py_INCREF(Py_None); resultobj = Py_None;
23573     return resultobj;
23574     fail:
23575     return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_PrintDialogData_SetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23580     PyObject *resultobj;
23581     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23582     int arg2 ;
23583     PyObject * obj0 = 0 ;
23584     PyObject * obj1 = 0 ;
23585     char *kwnames[] = {
23586         (char *) "self",(char *) "v", NULL
23587     };
23588
23589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMaxPage",kwnames,&obj0,&obj1)) goto fail;
23590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23591     if (SWIG_arg_fail(1)) SWIG_fail;
23592     {
23593         arg2 = (int)(SWIG_As_int(obj1));
23594         if (SWIG_arg_fail(2)) SWIG_fail;
23595     }
23596     {
23597         PyThreadState* __tstate = wxPyBeginAllowThreads();
23598         (arg1)->SetMaxPage(arg2);
23599
23600         wxPyEndAllowThreads(__tstate);
23601         if (PyErr_Occurred()) SWIG_fail;
23602     }
23603     Py_INCREF(Py_None); resultobj = Py_None;
23604     return resultobj;
23605     fail:
23606     return NULL;
23607 }
23608
23609
23610 static PyObject *_wrap_PrintDialogData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23611     PyObject *resultobj;
23612     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23613     int arg2 ;
23614     PyObject * obj0 = 0 ;
23615     PyObject * obj1 = 0 ;
23616     char *kwnames[] = {
23617         (char *) "self",(char *) "v", NULL
23618     };
23619
23620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
23621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23622     if (SWIG_arg_fail(1)) SWIG_fail;
23623     {
23624         arg2 = (int)(SWIG_As_int(obj1));
23625         if (SWIG_arg_fail(2)) SWIG_fail;
23626     }
23627     {
23628         PyThreadState* __tstate = wxPyBeginAllowThreads();
23629         (arg1)->SetNoCopies(arg2);
23630
23631         wxPyEndAllowThreads(__tstate);
23632         if (PyErr_Occurred()) SWIG_fail;
23633     }
23634     Py_INCREF(Py_None); resultobj = Py_None;
23635     return resultobj;
23636     fail:
23637     return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_PrintDialogData_SetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23642     PyObject *resultobj;
23643     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23644     bool arg2 ;
23645     PyObject * obj0 = 0 ;
23646     PyObject * obj1 = 0 ;
23647     char *kwnames[] = {
23648         (char *) "self",(char *) "flag", NULL
23649     };
23650
23651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetAllPages",kwnames,&obj0,&obj1)) goto fail;
23652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23653     if (SWIG_arg_fail(1)) SWIG_fail;
23654     {
23655         arg2 = (bool)(SWIG_As_bool(obj1));
23656         if (SWIG_arg_fail(2)) SWIG_fail;
23657     }
23658     {
23659         PyThreadState* __tstate = wxPyBeginAllowThreads();
23660         (arg1)->SetAllPages(arg2);
23661
23662         wxPyEndAllowThreads(__tstate);
23663         if (PyErr_Occurred()) SWIG_fail;
23664     }
23665     Py_INCREF(Py_None); resultobj = Py_None;
23666     return resultobj;
23667     fail:
23668     return NULL;
23669 }
23670
23671
23672 static PyObject *_wrap_PrintDialogData_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23673     PyObject *resultobj;
23674     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23675     bool arg2 ;
23676     PyObject * obj0 = 0 ;
23677     PyObject * obj1 = 0 ;
23678     char *kwnames[] = {
23679         (char *) "self",(char *) "flag", NULL
23680     };
23681
23682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSelection",kwnames,&obj0,&obj1)) goto fail;
23683     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23684     if (SWIG_arg_fail(1)) SWIG_fail;
23685     {
23686         arg2 = (bool)(SWIG_As_bool(obj1));
23687         if (SWIG_arg_fail(2)) SWIG_fail;
23688     }
23689     {
23690         PyThreadState* __tstate = wxPyBeginAllowThreads();
23691         (arg1)->SetSelection(arg2);
23692
23693         wxPyEndAllowThreads(__tstate);
23694         if (PyErr_Occurred()) SWIG_fail;
23695     }
23696     Py_INCREF(Py_None); resultobj = Py_None;
23697     return resultobj;
23698     fail:
23699     return NULL;
23700 }
23701
23702
23703 static PyObject *_wrap_PrintDialogData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23704     PyObject *resultobj;
23705     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23706     bool arg2 ;
23707     PyObject * obj0 = 0 ;
23708     PyObject * obj1 = 0 ;
23709     char *kwnames[] = {
23710         (char *) "self",(char *) "flag", NULL
23711     };
23712
23713     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
23714     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23715     if (SWIG_arg_fail(1)) SWIG_fail;
23716     {
23717         arg2 = (bool)(SWIG_As_bool(obj1));
23718         if (SWIG_arg_fail(2)) SWIG_fail;
23719     }
23720     {
23721         PyThreadState* __tstate = wxPyBeginAllowThreads();
23722         (arg1)->SetCollate(arg2);
23723
23724         wxPyEndAllowThreads(__tstate);
23725         if (PyErr_Occurred()) SWIG_fail;
23726     }
23727     Py_INCREF(Py_None); resultobj = Py_None;
23728     return resultobj;
23729     fail:
23730     return NULL;
23731 }
23732
23733
23734 static PyObject *_wrap_PrintDialogData_SetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23735     PyObject *resultobj;
23736     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23737     bool arg2 ;
23738     PyObject * obj0 = 0 ;
23739     PyObject * obj1 = 0 ;
23740     char *kwnames[] = {
23741         (char *) "self",(char *) "flag", NULL
23742     };
23743
23744     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintToFile",kwnames,&obj0,&obj1)) goto fail;
23745     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23746     if (SWIG_arg_fail(1)) SWIG_fail;
23747     {
23748         arg2 = (bool)(SWIG_As_bool(obj1));
23749         if (SWIG_arg_fail(2)) SWIG_fail;
23750     }
23751     {
23752         PyThreadState* __tstate = wxPyBeginAllowThreads();
23753         (arg1)->SetPrintToFile(arg2);
23754
23755         wxPyEndAllowThreads(__tstate);
23756         if (PyErr_Occurred()) SWIG_fail;
23757     }
23758     Py_INCREF(Py_None); resultobj = Py_None;
23759     return resultobj;
23760     fail:
23761     return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_PrintDialogData_EnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23766     PyObject *resultobj;
23767     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23768     bool arg2 ;
23769     PyObject * obj0 = 0 ;
23770     PyObject * obj1 = 0 ;
23771     char *kwnames[] = {
23772         (char *) "self",(char *) "flag", NULL
23773     };
23774
23775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePrintToFile",kwnames,&obj0,&obj1)) goto fail;
23776     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23777     if (SWIG_arg_fail(1)) SWIG_fail;
23778     {
23779         arg2 = (bool)(SWIG_As_bool(obj1));
23780         if (SWIG_arg_fail(2)) SWIG_fail;
23781     }
23782     {
23783         PyThreadState* __tstate = wxPyBeginAllowThreads();
23784         (arg1)->EnablePrintToFile(arg2);
23785
23786         wxPyEndAllowThreads(__tstate);
23787         if (PyErr_Occurred()) SWIG_fail;
23788     }
23789     Py_INCREF(Py_None); resultobj = Py_None;
23790     return resultobj;
23791     fail:
23792     return NULL;
23793 }
23794
23795
23796 static PyObject *_wrap_PrintDialogData_EnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23797     PyObject *resultobj;
23798     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23799     bool arg2 ;
23800     PyObject * obj0 = 0 ;
23801     PyObject * obj1 = 0 ;
23802     char *kwnames[] = {
23803         (char *) "self",(char *) "flag", NULL
23804     };
23805
23806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableSelection",kwnames,&obj0,&obj1)) goto fail;
23807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23808     if (SWIG_arg_fail(1)) SWIG_fail;
23809     {
23810         arg2 = (bool)(SWIG_As_bool(obj1));
23811         if (SWIG_arg_fail(2)) SWIG_fail;
23812     }
23813     {
23814         PyThreadState* __tstate = wxPyBeginAllowThreads();
23815         (arg1)->EnableSelection(arg2);
23816
23817         wxPyEndAllowThreads(__tstate);
23818         if (PyErr_Occurred()) SWIG_fail;
23819     }
23820     Py_INCREF(Py_None); resultobj = Py_None;
23821     return resultobj;
23822     fail:
23823     return NULL;
23824 }
23825
23826
23827 static PyObject *_wrap_PrintDialogData_EnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23828     PyObject *resultobj;
23829     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23830     bool arg2 ;
23831     PyObject * obj0 = 0 ;
23832     PyObject * obj1 = 0 ;
23833     char *kwnames[] = {
23834         (char *) "self",(char *) "flag", NULL
23835     };
23836
23837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePageNumbers",kwnames,&obj0,&obj1)) goto fail;
23838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23839     if (SWIG_arg_fail(1)) SWIG_fail;
23840     {
23841         arg2 = (bool)(SWIG_As_bool(obj1));
23842         if (SWIG_arg_fail(2)) SWIG_fail;
23843     }
23844     {
23845         PyThreadState* __tstate = wxPyBeginAllowThreads();
23846         (arg1)->EnablePageNumbers(arg2);
23847
23848         wxPyEndAllowThreads(__tstate);
23849         if (PyErr_Occurred()) SWIG_fail;
23850     }
23851     Py_INCREF(Py_None); resultobj = Py_None;
23852     return resultobj;
23853     fail:
23854     return NULL;
23855 }
23856
23857
23858 static PyObject *_wrap_PrintDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23859     PyObject *resultobj;
23860     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23861     bool arg2 ;
23862     PyObject * obj0 = 0 ;
23863     PyObject * obj1 = 0 ;
23864     char *kwnames[] = {
23865         (char *) "self",(char *) "flag", NULL
23866     };
23867
23868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
23869     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23870     if (SWIG_arg_fail(1)) SWIG_fail;
23871     {
23872         arg2 = (bool)(SWIG_As_bool(obj1));
23873         if (SWIG_arg_fail(2)) SWIG_fail;
23874     }
23875     {
23876         PyThreadState* __tstate = wxPyBeginAllowThreads();
23877         (arg1)->EnableHelp(arg2);
23878
23879         wxPyEndAllowThreads(__tstate);
23880         if (PyErr_Occurred()) SWIG_fail;
23881     }
23882     Py_INCREF(Py_None); resultobj = Py_None;
23883     return resultobj;
23884     fail:
23885     return NULL;
23886 }
23887
23888
23889 static PyObject *_wrap_PrintDialogData_GetEnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23890     PyObject *resultobj;
23891     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23892     bool result;
23893     PyObject * obj0 = 0 ;
23894     char *kwnames[] = {
23895         (char *) "self", NULL
23896     };
23897
23898     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePrintToFile",kwnames,&obj0)) goto fail;
23899     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23900     if (SWIG_arg_fail(1)) SWIG_fail;
23901     {
23902         PyThreadState* __tstate = wxPyBeginAllowThreads();
23903         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePrintToFile();
23904
23905         wxPyEndAllowThreads(__tstate);
23906         if (PyErr_Occurred()) SWIG_fail;
23907     }
23908     {
23909         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23910     }
23911     return resultobj;
23912     fail:
23913     return NULL;
23914 }
23915
23916
23917 static PyObject *_wrap_PrintDialogData_GetEnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23918     PyObject *resultobj;
23919     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23920     bool result;
23921     PyObject * obj0 = 0 ;
23922     char *kwnames[] = {
23923         (char *) "self", NULL
23924     };
23925
23926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableSelection",kwnames,&obj0)) goto fail;
23927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23928     if (SWIG_arg_fail(1)) SWIG_fail;
23929     {
23930         PyThreadState* __tstate = wxPyBeginAllowThreads();
23931         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableSelection();
23932
23933         wxPyEndAllowThreads(__tstate);
23934         if (PyErr_Occurred()) SWIG_fail;
23935     }
23936     {
23937         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938     }
23939     return resultobj;
23940     fail:
23941     return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_PrintDialogData_GetEnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23946     PyObject *resultobj;
23947     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23948     bool result;
23949     PyObject * obj0 = 0 ;
23950     char *kwnames[] = {
23951         (char *) "self", NULL
23952     };
23953
23954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePageNumbers",kwnames,&obj0)) 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         PyThreadState* __tstate = wxPyBeginAllowThreads();
23959         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePageNumbers();
23960
23961         wxPyEndAllowThreads(__tstate);
23962         if (PyErr_Occurred()) SWIG_fail;
23963     }
23964     {
23965         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23966     }
23967     return resultobj;
23968     fail:
23969     return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_PrintDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23974     PyObject *resultobj;
23975     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23976     bool result;
23977     PyObject * obj0 = 0 ;
23978     char *kwnames[] = {
23979         (char *) "self", NULL
23980     };
23981
23982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
23983     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23984     if (SWIG_arg_fail(1)) SWIG_fail;
23985     {
23986         PyThreadState* __tstate = wxPyBeginAllowThreads();
23987         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableHelp();
23988
23989         wxPyEndAllowThreads(__tstate);
23990         if (PyErr_Occurred()) SWIG_fail;
23991     }
23992     {
23993         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23994     }
23995     return resultobj;
23996     fail:
23997     return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_PrintDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24002     PyObject *resultobj;
24003     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24004     bool result;
24005     PyObject * obj0 = 0 ;
24006     char *kwnames[] = {
24007         (char *) "self", NULL
24008     };
24009
24010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_Ok",kwnames,&obj0)) goto fail;
24011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24012     if (SWIG_arg_fail(1)) SWIG_fail;
24013     {
24014         PyThreadState* __tstate = wxPyBeginAllowThreads();
24015         result = (bool)((wxPrintDialogData const *)arg1)->Ok();
24016
24017         wxPyEndAllowThreads(__tstate);
24018         if (PyErr_Occurred()) SWIG_fail;
24019     }
24020     {
24021         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24022     }
24023     return resultobj;
24024     fail:
24025     return NULL;
24026 }
24027
24028
24029 static PyObject *_wrap_PrintDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24030     PyObject *resultobj;
24031     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24032     wxPrintData *result;
24033     PyObject * obj0 = 0 ;
24034     char *kwnames[] = {
24035         (char *) "self", NULL
24036     };
24037
24038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintData",kwnames,&obj0)) goto fail;
24039     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24040     if (SWIG_arg_fail(1)) SWIG_fail;
24041     {
24042         PyThreadState* __tstate = wxPyBeginAllowThreads();
24043         {
24044             wxPrintData &_result_ref = (arg1)->GetPrintData();
24045             result = (wxPrintData *) &_result_ref;
24046         }
24047
24048         wxPyEndAllowThreads(__tstate);
24049         if (PyErr_Occurred()) SWIG_fail;
24050     }
24051     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24052     return resultobj;
24053     fail:
24054     return NULL;
24055 }
24056
24057
24058 static PyObject *_wrap_PrintDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24059     PyObject *resultobj;
24060     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24061     wxPrintData *arg2 = 0 ;
24062     PyObject * obj0 = 0 ;
24063     PyObject * obj1 = 0 ;
24064     char *kwnames[] = {
24065         (char *) "self",(char *) "printData", NULL
24066     };
24067
24068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
24069     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24070     if (SWIG_arg_fail(1)) SWIG_fail;
24071     {
24072         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
24073         if (SWIG_arg_fail(2)) SWIG_fail;
24074         if (arg2 == NULL) {
24075             SWIG_null_ref("wxPrintData");
24076         }
24077         if (SWIG_arg_fail(2)) SWIG_fail;
24078     }
24079     {
24080         PyThreadState* __tstate = wxPyBeginAllowThreads();
24081         (arg1)->SetPrintData((wxPrintData const &)*arg2);
24082
24083         wxPyEndAllowThreads(__tstate);
24084         if (PyErr_Occurred()) SWIG_fail;
24085     }
24086     Py_INCREF(Py_None); resultobj = Py_None;
24087     return resultobj;
24088     fail:
24089     return NULL;
24090 }
24091
24092
24093 static PyObject * PrintDialogData_swigregister(PyObject *, PyObject *args) {
24094     PyObject *obj;
24095     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24096     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialogData, obj);
24097     Py_INCREF(obj);
24098     return Py_BuildValue((char *)"");
24099 }
24100 static PyObject *_wrap_new_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24101     PyObject *resultobj;
24102     wxWindow *arg1 = (wxWindow *) 0 ;
24103     wxPrintDialogData *arg2 = (wxPrintDialogData *) NULL ;
24104     wxPrintDialog *result;
24105     PyObject * obj0 = 0 ;
24106     PyObject * obj1 = 0 ;
24107     char *kwnames[] = {
24108         (char *) "parent",(char *) "data", NULL
24109     };
24110
24111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24113     if (SWIG_arg_fail(1)) SWIG_fail;
24114     if (obj1) {
24115         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24116         if (SWIG_arg_fail(2)) SWIG_fail;
24117     }
24118     {
24119         if (!wxPyCheckForApp()) SWIG_fail;
24120         PyThreadState* __tstate = wxPyBeginAllowThreads();
24121         result = (wxPrintDialog *)new wxPrintDialog(arg1,arg2);
24122
24123         wxPyEndAllowThreads(__tstate);
24124         if (PyErr_Occurred()) SWIG_fail;
24125     }
24126     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialog, 1);
24127     return resultobj;
24128     fail:
24129     return NULL;
24130 }
24131
24132
24133 static PyObject *_wrap_PrintDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
24134     PyObject *resultobj;
24135     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24136     int result;
24137     PyObject * obj0 = 0 ;
24138     char *kwnames[] = {
24139         (char *) "self", NULL
24140     };
24141
24142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_ShowModal",kwnames,&obj0)) goto fail;
24143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24144     if (SWIG_arg_fail(1)) SWIG_fail;
24145     {
24146         PyThreadState* __tstate = wxPyBeginAllowThreads();
24147         result = (int)(arg1)->ShowModal();
24148
24149         wxPyEndAllowThreads(__tstate);
24150         if (PyErr_Occurred()) SWIG_fail;
24151     }
24152     {
24153         resultobj = SWIG_From_int((int)(result));
24154     }
24155     return resultobj;
24156     fail:
24157     return NULL;
24158 }
24159
24160
24161 static PyObject *_wrap_PrintDialog_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24162     PyObject *resultobj;
24163     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24164     wxPrintDialogData *result;
24165     PyObject * obj0 = 0 ;
24166     char *kwnames[] = {
24167         (char *) "self", NULL
24168     };
24169
24170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDialogData",kwnames,&obj0)) goto fail;
24171     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24172     if (SWIG_arg_fail(1)) SWIG_fail;
24173     {
24174         PyThreadState* __tstate = wxPyBeginAllowThreads();
24175         {
24176             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
24177             result = (wxPrintDialogData *) &_result_ref;
24178         }
24179
24180         wxPyEndAllowThreads(__tstate);
24181         if (PyErr_Occurred()) SWIG_fail;
24182     }
24183     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24184     return resultobj;
24185     fail:
24186     return NULL;
24187 }
24188
24189
24190 static PyObject *_wrap_PrintDialog_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24191     PyObject *resultobj;
24192     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24193     wxPrintData *result;
24194     PyObject * obj0 = 0 ;
24195     char *kwnames[] = {
24196         (char *) "self", NULL
24197     };
24198
24199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintData",kwnames,&obj0)) goto fail;
24200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24201     if (SWIG_arg_fail(1)) SWIG_fail;
24202     {
24203         PyThreadState* __tstate = wxPyBeginAllowThreads();
24204         {
24205             wxPrintData &_result_ref = (arg1)->GetPrintData();
24206             result = (wxPrintData *) &_result_ref;
24207         }
24208
24209         wxPyEndAllowThreads(__tstate);
24210         if (PyErr_Occurred()) SWIG_fail;
24211     }
24212     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24213     return resultobj;
24214     fail:
24215     return NULL;
24216 }
24217
24218
24219 static PyObject *_wrap_PrintDialog_GetPrintDC(PyObject *, PyObject *args, PyObject *kwargs) {
24220     PyObject *resultobj;
24221     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24222     wxDC *result;
24223     PyObject * obj0 = 0 ;
24224     char *kwnames[] = {
24225         (char *) "self", NULL
24226     };
24227
24228     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDC",kwnames,&obj0)) goto fail;
24229     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24230     if (SWIG_arg_fail(1)) SWIG_fail;
24231     {
24232         PyThreadState* __tstate = wxPyBeginAllowThreads();
24233         result = (wxDC *)(arg1)->GetPrintDC();
24234
24235         wxPyEndAllowThreads(__tstate);
24236         if (PyErr_Occurred()) SWIG_fail;
24237     }
24238     {
24239         resultobj = wxPyMake_wxObject(result, 1);
24240     }
24241     return resultobj;
24242     fail:
24243     return NULL;
24244 }
24245
24246
24247 static PyObject * PrintDialog_swigregister(PyObject *, PyObject *args) {
24248     PyObject *obj;
24249     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24250     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialog, obj);
24251     Py_INCREF(obj);
24252     return Py_BuildValue((char *)"");
24253 }
24254 static PyObject *_wrap_new_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24255     PyObject *resultobj;
24256     wxPrintDialogData *arg1 = (wxPrintDialogData *) NULL ;
24257     wxPrinter *result;
24258     PyObject * obj0 = 0 ;
24259     char *kwnames[] = {
24260         (char *) "data", NULL
24261     };
24262
24263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printer",kwnames,&obj0)) goto fail;
24264     if (obj0) {
24265         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24266         if (SWIG_arg_fail(1)) SWIG_fail;
24267     }
24268     {
24269         if (!wxPyCheckForApp()) SWIG_fail;
24270         PyThreadState* __tstate = wxPyBeginAllowThreads();
24271         result = (wxPrinter *)new wxPrinter(arg1);
24272
24273         wxPyEndAllowThreads(__tstate);
24274         if (PyErr_Occurred()) SWIG_fail;
24275     }
24276     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinter, 1);
24277     return resultobj;
24278     fail:
24279     return NULL;
24280 }
24281
24282
24283 static PyObject *_wrap_delete_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24284     PyObject *resultobj;
24285     wxPrinter *arg1 = (wxPrinter *) 0 ;
24286     PyObject * obj0 = 0 ;
24287     char *kwnames[] = {
24288         (char *) "self", NULL
24289     };
24290
24291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Printer",kwnames,&obj0)) goto fail;
24292     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24293     if (SWIG_arg_fail(1)) SWIG_fail;
24294     {
24295         PyThreadState* __tstate = wxPyBeginAllowThreads();
24296         delete arg1;
24297
24298         wxPyEndAllowThreads(__tstate);
24299         if (PyErr_Occurred()) SWIG_fail;
24300     }
24301     Py_INCREF(Py_None); resultobj = Py_None;
24302     return resultobj;
24303     fail:
24304     return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_Printer_CreateAbortWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24309     PyObject *resultobj;
24310     wxPrinter *arg1 = (wxPrinter *) 0 ;
24311     wxWindow *arg2 = (wxWindow *) 0 ;
24312     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24313     wxWindow *result;
24314     PyObject * obj0 = 0 ;
24315     PyObject * obj1 = 0 ;
24316     PyObject * obj2 = 0 ;
24317     char *kwnames[] = {
24318         (char *) "self",(char *) "parent",(char *) "printout", NULL
24319     };
24320
24321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printer_CreateAbortWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
24322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24323     if (SWIG_arg_fail(1)) SWIG_fail;
24324     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24325     if (SWIG_arg_fail(2)) SWIG_fail;
24326     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24327     if (SWIG_arg_fail(3)) SWIG_fail;
24328     {
24329         PyThreadState* __tstate = wxPyBeginAllowThreads();
24330         result = (wxWindow *)(arg1)->CreateAbortWindow(arg2,arg3);
24331
24332         wxPyEndAllowThreads(__tstate);
24333         if (PyErr_Occurred()) SWIG_fail;
24334     }
24335     {
24336         resultobj = wxPyMake_wxObject(result, 0);
24337     }
24338     return resultobj;
24339     fail:
24340     return NULL;
24341 }
24342
24343
24344 static PyObject *_wrap_Printer_ReportError(PyObject *, PyObject *args, PyObject *kwargs) {
24345     PyObject *resultobj;
24346     wxPrinter *arg1 = (wxPrinter *) 0 ;
24347     wxWindow *arg2 = (wxWindow *) 0 ;
24348     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24349     wxString *arg4 = 0 ;
24350     bool temp4 = false ;
24351     PyObject * obj0 = 0 ;
24352     PyObject * obj1 = 0 ;
24353     PyObject * obj2 = 0 ;
24354     PyObject * obj3 = 0 ;
24355     char *kwnames[] = {
24356         (char *) "self",(char *) "parent",(char *) "printout",(char *) "message", NULL
24357     };
24358
24359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Printer_ReportError",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24360     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24361     if (SWIG_arg_fail(1)) SWIG_fail;
24362     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24363     if (SWIG_arg_fail(2)) SWIG_fail;
24364     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24365     if (SWIG_arg_fail(3)) SWIG_fail;
24366     {
24367         arg4 = wxString_in_helper(obj3);
24368         if (arg4 == NULL) SWIG_fail;
24369         temp4 = true;
24370     }
24371     {
24372         PyThreadState* __tstate = wxPyBeginAllowThreads();
24373         (arg1)->ReportError(arg2,arg3,(wxString const &)*arg4);
24374
24375         wxPyEndAllowThreads(__tstate);
24376         if (PyErr_Occurred()) SWIG_fail;
24377     }
24378     Py_INCREF(Py_None); resultobj = Py_None;
24379     {
24380         if (temp4)
24381         delete arg4;
24382     }
24383     return resultobj;
24384     fail:
24385     {
24386         if (temp4)
24387         delete arg4;
24388     }
24389     return NULL;
24390 }
24391
24392
24393 static PyObject *_wrap_Printer_Setup(PyObject *, PyObject *args, PyObject *kwargs) {
24394     PyObject *resultobj;
24395     wxPrinter *arg1 = (wxPrinter *) 0 ;
24396     wxWindow *arg2 = (wxWindow *) 0 ;
24397     bool result;
24398     PyObject * obj0 = 0 ;
24399     PyObject * obj1 = 0 ;
24400     char *kwnames[] = {
24401         (char *) "self",(char *) "parent", NULL
24402     };
24403
24404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_Setup",kwnames,&obj0,&obj1)) goto fail;
24405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24406     if (SWIG_arg_fail(1)) SWIG_fail;
24407     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24408     if (SWIG_arg_fail(2)) SWIG_fail;
24409     {
24410         PyThreadState* __tstate = wxPyBeginAllowThreads();
24411         result = (bool)(arg1)->Setup(arg2);
24412
24413         wxPyEndAllowThreads(__tstate);
24414         if (PyErr_Occurred()) SWIG_fail;
24415     }
24416     {
24417         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24418     }
24419     return resultobj;
24420     fail:
24421     return NULL;
24422 }
24423
24424
24425 static PyObject *_wrap_Printer_Print(PyObject *, PyObject *args, PyObject *kwargs) {
24426     PyObject *resultobj;
24427     wxPrinter *arg1 = (wxPrinter *) 0 ;
24428     wxWindow *arg2 = (wxWindow *) 0 ;
24429     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24430     bool arg4 = (bool) true ;
24431     bool result;
24432     PyObject * obj0 = 0 ;
24433     PyObject * obj1 = 0 ;
24434     PyObject * obj2 = 0 ;
24435     PyObject * obj3 = 0 ;
24436     char *kwnames[] = {
24437         (char *) "self",(char *) "parent",(char *) "printout",(char *) "prompt", NULL
24438     };
24439
24440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Printer_Print",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24442     if (SWIG_arg_fail(1)) SWIG_fail;
24443     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24444     if (SWIG_arg_fail(2)) SWIG_fail;
24445     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24446     if (SWIG_arg_fail(3)) SWIG_fail;
24447     if (obj3) {
24448         {
24449             arg4 = (bool)(SWIG_As_bool(obj3));
24450             if (SWIG_arg_fail(4)) SWIG_fail;
24451         }
24452     }
24453     {
24454         PyThreadState* __tstate = wxPyBeginAllowThreads();
24455         result = (bool)(arg1)->Print(arg2,arg3,arg4);
24456
24457         wxPyEndAllowThreads(__tstate);
24458         if (PyErr_Occurred()) SWIG_fail;
24459     }
24460     {
24461         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24462     }
24463     return resultobj;
24464     fail:
24465     return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_Printer_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24470     PyObject *resultobj;
24471     wxPrinter *arg1 = (wxPrinter *) 0 ;
24472     wxWindow *arg2 = (wxWindow *) 0 ;
24473     wxDC *result;
24474     PyObject * obj0 = 0 ;
24475     PyObject * obj1 = 0 ;
24476     char *kwnames[] = {
24477         (char *) "self",(char *) "parent", NULL
24478     };
24479
24480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24482     if (SWIG_arg_fail(1)) SWIG_fail;
24483     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24484     if (SWIG_arg_fail(2)) SWIG_fail;
24485     {
24486         PyThreadState* __tstate = wxPyBeginAllowThreads();
24487         result = (wxDC *)(arg1)->PrintDialog(arg2);
24488
24489         wxPyEndAllowThreads(__tstate);
24490         if (PyErr_Occurred()) SWIG_fail;
24491     }
24492     {
24493         resultobj = wxPyMake_wxObject(result, 0);
24494     }
24495     return resultobj;
24496     fail:
24497     return NULL;
24498 }
24499
24500
24501 static PyObject *_wrap_Printer_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24502     PyObject *resultobj;
24503     wxPrinter *arg1 = (wxPrinter *) 0 ;
24504     wxPrintDialogData *result;
24505     PyObject * obj0 = 0 ;
24506     char *kwnames[] = {
24507         (char *) "self", NULL
24508     };
24509
24510     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetPrintDialogData",kwnames,&obj0)) goto fail;
24511     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24512     if (SWIG_arg_fail(1)) SWIG_fail;
24513     {
24514         PyThreadState* __tstate = wxPyBeginAllowThreads();
24515         {
24516             wxPrintDialogData &_result_ref = ((wxPrinter const *)arg1)->GetPrintDialogData();
24517             result = (wxPrintDialogData *) &_result_ref;
24518         }
24519
24520         wxPyEndAllowThreads(__tstate);
24521         if (PyErr_Occurred()) SWIG_fail;
24522     }
24523     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24524     return resultobj;
24525     fail:
24526     return NULL;
24527 }
24528
24529
24530 static PyObject *_wrap_Printer_GetAbort(PyObject *, PyObject *args, PyObject *kwargs) {
24531     PyObject *resultobj;
24532     wxPrinter *arg1 = (wxPrinter *) 0 ;
24533     bool result;
24534     PyObject * obj0 = 0 ;
24535     char *kwnames[] = {
24536         (char *) "self", NULL
24537     };
24538
24539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetAbort",kwnames,&obj0)) goto fail;
24540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24541     if (SWIG_arg_fail(1)) SWIG_fail;
24542     {
24543         PyThreadState* __tstate = wxPyBeginAllowThreads();
24544         result = (bool)(arg1)->GetAbort();
24545
24546         wxPyEndAllowThreads(__tstate);
24547         if (PyErr_Occurred()) SWIG_fail;
24548     }
24549     {
24550         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24551     }
24552     return resultobj;
24553     fail:
24554     return NULL;
24555 }
24556
24557
24558 static PyObject *_wrap_Printer_GetLastError(PyObject *, PyObject *args, PyObject *kwargs) {
24559     PyObject *resultobj;
24560     wxPrinterError result;
24561     char *kwnames[] = {
24562         NULL
24563     };
24564
24565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Printer_GetLastError",kwnames)) goto fail;
24566     {
24567         PyThreadState* __tstate = wxPyBeginAllowThreads();
24568         result = (wxPrinterError)wxPrinter::GetLastError();
24569
24570         wxPyEndAllowThreads(__tstate);
24571         if (PyErr_Occurred()) SWIG_fail;
24572     }
24573     resultobj = SWIG_From_int((result));
24574     return resultobj;
24575     fail:
24576     return NULL;
24577 }
24578
24579
24580 static PyObject * Printer_swigregister(PyObject *, PyObject *args) {
24581     PyObject *obj;
24582     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24583     SWIG_TypeClientData(SWIGTYPE_p_wxPrinter, obj);
24584     Py_INCREF(obj);
24585     return Py_BuildValue((char *)"");
24586 }
24587 static PyObject *_wrap_new_Printout(PyObject *, PyObject *args, PyObject *kwargs) {
24588     PyObject *resultobj;
24589     wxString const &arg1_defvalue = wxPyPrintoutTitleStr ;
24590     wxString *arg1 = (wxString *) &arg1_defvalue ;
24591     wxPyPrintout *result;
24592     bool temp1 = false ;
24593     PyObject * obj0 = 0 ;
24594     char *kwnames[] = {
24595         (char *) "title", NULL
24596     };
24597
24598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printout",kwnames,&obj0)) goto fail;
24599     if (obj0) {
24600         {
24601             arg1 = wxString_in_helper(obj0);
24602             if (arg1 == NULL) SWIG_fail;
24603             temp1 = true;
24604         }
24605     }
24606     {
24607         if (!wxPyCheckForApp()) SWIG_fail;
24608         PyThreadState* __tstate = wxPyBeginAllowThreads();
24609         result = (wxPyPrintout *)new wxPyPrintout((wxString const &)*arg1);
24610
24611         wxPyEndAllowThreads(__tstate);
24612         if (PyErr_Occurred()) SWIG_fail;
24613     }
24614     {
24615         resultobj = wxPyMake_wxObject(result, 1);
24616     }
24617     {
24618         if (temp1)
24619         delete arg1;
24620     }
24621     return resultobj;
24622     fail:
24623     {
24624         if (temp1)
24625         delete arg1;
24626     }
24627     return NULL;
24628 }
24629
24630
24631 static PyObject *_wrap_Printout__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24632     PyObject *resultobj;
24633     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24634     PyObject *arg2 = (PyObject *) 0 ;
24635     PyObject *arg3 = (PyObject *) 0 ;
24636     PyObject * obj0 = 0 ;
24637     PyObject * obj1 = 0 ;
24638     PyObject * obj2 = 0 ;
24639     char *kwnames[] = {
24640         (char *) "self",(char *) "self",(char *) "_class", NULL
24641     };
24642
24643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24645     if (SWIG_arg_fail(1)) SWIG_fail;
24646     arg2 = obj1;
24647     arg3 = obj2;
24648     {
24649         PyThreadState* __tstate = wxPyBeginAllowThreads();
24650         (arg1)->_setCallbackInfo(arg2,arg3);
24651
24652         wxPyEndAllowThreads(__tstate);
24653         if (PyErr_Occurred()) SWIG_fail;
24654     }
24655     Py_INCREF(Py_None); resultobj = Py_None;
24656     return resultobj;
24657     fail:
24658     return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_Printout_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24663     PyObject *resultobj;
24664     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24665     wxString result;
24666     PyObject * obj0 = 0 ;
24667     char *kwnames[] = {
24668         (char *) "self", NULL
24669     };
24670
24671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetTitle",kwnames,&obj0)) goto fail;
24672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24673     if (SWIG_arg_fail(1)) SWIG_fail;
24674     {
24675         PyThreadState* __tstate = wxPyBeginAllowThreads();
24676         result = ((wxPyPrintout const *)arg1)->GetTitle();
24677
24678         wxPyEndAllowThreads(__tstate);
24679         if (PyErr_Occurred()) SWIG_fail;
24680     }
24681     {
24682 #if wxUSE_UNICODE
24683         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24684 #else
24685         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24686 #endif
24687     }
24688     return resultobj;
24689     fail:
24690     return NULL;
24691 }
24692
24693
24694 static PyObject *_wrap_Printout_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24695     PyObject *resultobj;
24696     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24697     wxDC *result;
24698     PyObject * obj0 = 0 ;
24699     char *kwnames[] = {
24700         (char *) "self", NULL
24701     };
24702
24703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetDC",kwnames,&obj0)) goto fail;
24704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24705     if (SWIG_arg_fail(1)) SWIG_fail;
24706     {
24707         PyThreadState* __tstate = wxPyBeginAllowThreads();
24708         result = (wxDC *)(arg1)->GetDC();
24709
24710         wxPyEndAllowThreads(__tstate);
24711         if (PyErr_Occurred()) SWIG_fail;
24712     }
24713     {
24714         resultobj = wxPyMake_wxObject(result, 0);
24715     }
24716     return resultobj;
24717     fail:
24718     return NULL;
24719 }
24720
24721
24722 static PyObject *_wrap_Printout_SetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24723     PyObject *resultobj;
24724     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24725     wxDC *arg2 = (wxDC *) 0 ;
24726     PyObject * obj0 = 0 ;
24727     PyObject * obj1 = 0 ;
24728     char *kwnames[] = {
24729         (char *) "self",(char *) "dc", NULL
24730     };
24731
24732     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetDC",kwnames,&obj0,&obj1)) goto fail;
24733     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24734     if (SWIG_arg_fail(1)) SWIG_fail;
24735     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
24736     if (SWIG_arg_fail(2)) SWIG_fail;
24737     {
24738         PyThreadState* __tstate = wxPyBeginAllowThreads();
24739         (arg1)->SetDC(arg2);
24740
24741         wxPyEndAllowThreads(__tstate);
24742         if (PyErr_Occurred()) SWIG_fail;
24743     }
24744     Py_INCREF(Py_None); resultobj = Py_None;
24745     return resultobj;
24746     fail:
24747     return NULL;
24748 }
24749
24750
24751 static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24752     PyObject *resultobj;
24753     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24754     int arg2 ;
24755     int arg3 ;
24756     PyObject * obj0 = 0 ;
24757     PyObject * obj1 = 0 ;
24758     PyObject * obj2 = 0 ;
24759     char *kwnames[] = {
24760         (char *) "self",(char *) "w",(char *) "h", NULL
24761     };
24762
24763     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizePixels",kwnames,&obj0,&obj1,&obj2)) goto fail;
24764     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24765     if (SWIG_arg_fail(1)) SWIG_fail;
24766     {
24767         arg2 = (int)(SWIG_As_int(obj1));
24768         if (SWIG_arg_fail(2)) SWIG_fail;
24769     }
24770     {
24771         arg3 = (int)(SWIG_As_int(obj2));
24772         if (SWIG_arg_fail(3)) SWIG_fail;
24773     }
24774     {
24775         PyThreadState* __tstate = wxPyBeginAllowThreads();
24776         (arg1)->SetPageSizePixels(arg2,arg3);
24777
24778         wxPyEndAllowThreads(__tstate);
24779         if (PyErr_Occurred()) SWIG_fail;
24780     }
24781     Py_INCREF(Py_None); resultobj = Py_None;
24782     return resultobj;
24783     fail:
24784     return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24789     PyObject *resultobj;
24790     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24791     int *arg2 = (int *) 0 ;
24792     int *arg3 = (int *) 0 ;
24793     int temp2 ;
24794     int res2 = 0 ;
24795     int temp3 ;
24796     int res3 = 0 ;
24797     PyObject * obj0 = 0 ;
24798     char *kwnames[] = {
24799         (char *) "self", NULL
24800     };
24801
24802     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24803     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24804     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizePixels",kwnames,&obj0)) goto fail;
24805     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24806     if (SWIG_arg_fail(1)) SWIG_fail;
24807     {
24808         PyThreadState* __tstate = wxPyBeginAllowThreads();
24809         (arg1)->GetPageSizePixels(arg2,arg3);
24810
24811         wxPyEndAllowThreads(__tstate);
24812         if (PyErr_Occurred()) SWIG_fail;
24813     }
24814     Py_INCREF(Py_None); resultobj = Py_None;
24815     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24816     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24817     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24818     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24819     return resultobj;
24820     fail:
24821     return NULL;
24822 }
24823
24824
24825 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24826     PyObject *resultobj;
24827     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24828     int arg2 ;
24829     int arg3 ;
24830     PyObject * obj0 = 0 ;
24831     PyObject * obj1 = 0 ;
24832     PyObject * obj2 = 0 ;
24833     char *kwnames[] = {
24834         (char *) "self",(char *) "w",(char *) "h", NULL
24835     };
24836
24837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizeMM",kwnames,&obj0,&obj1,&obj2)) goto fail;
24838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24839     if (SWIG_arg_fail(1)) SWIG_fail;
24840     {
24841         arg2 = (int)(SWIG_As_int(obj1));
24842         if (SWIG_arg_fail(2)) SWIG_fail;
24843     }
24844     {
24845         arg3 = (int)(SWIG_As_int(obj2));
24846         if (SWIG_arg_fail(3)) SWIG_fail;
24847     }
24848     {
24849         PyThreadState* __tstate = wxPyBeginAllowThreads();
24850         (arg1)->SetPageSizeMM(arg2,arg3);
24851
24852         wxPyEndAllowThreads(__tstate);
24853         if (PyErr_Occurred()) SWIG_fail;
24854     }
24855     Py_INCREF(Py_None); resultobj = Py_None;
24856     return resultobj;
24857     fail:
24858     return NULL;
24859 }
24860
24861
24862 static PyObject *_wrap_Printout_GetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24863     PyObject *resultobj;
24864     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24865     int *arg2 = (int *) 0 ;
24866     int *arg3 = (int *) 0 ;
24867     int temp2 ;
24868     int res2 = 0 ;
24869     int temp3 ;
24870     int res3 = 0 ;
24871     PyObject * obj0 = 0 ;
24872     char *kwnames[] = {
24873         (char *) "self", NULL
24874     };
24875
24876     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24877     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizeMM",kwnames,&obj0)) goto fail;
24879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24880     if (SWIG_arg_fail(1)) SWIG_fail;
24881     {
24882         PyThreadState* __tstate = wxPyBeginAllowThreads();
24883         (arg1)->GetPageSizeMM(arg2,arg3);
24884
24885         wxPyEndAllowThreads(__tstate);
24886         if (PyErr_Occurred()) SWIG_fail;
24887     }
24888     Py_INCREF(Py_None); resultobj = Py_None;
24889     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24890     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24891     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24892     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24893     return resultobj;
24894     fail:
24895     return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_Printout_SetPPIScreen(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 *) "x",(char *) "y", NULL
24909     };
24910
24911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIScreen",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)->SetPPIScreen(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_GetPPIScreen(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_GetPPIScreen",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)->GetPPIScreen(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_SetPPIPrinter(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 *) "x",(char *) "y", NULL
24983     };
24984
24985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIPrinter",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)->SetPPIPrinter(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_GetPPIPrinter(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_GetPPIPrinter",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)->GetPPIPrinter(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_IsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25048     PyObject *resultobj;
25049     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25050     bool result;
25051     PyObject * obj0 = 0 ;
25052     char *kwnames[] = {
25053         (char *) "self", NULL
25054     };
25055
25056     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_IsPreview",kwnames,&obj0)) goto fail;
25057     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25058     if (SWIG_arg_fail(1)) SWIG_fail;
25059     {
25060         PyThreadState* __tstate = wxPyBeginAllowThreads();
25061         result = (bool)(arg1)->IsPreview();
25062
25063         wxPyEndAllowThreads(__tstate);
25064         if (PyErr_Occurred()) SWIG_fail;
25065     }
25066     {
25067         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25068     }
25069     return resultobj;
25070     fail:
25071     return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_Printout_SetIsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25076     PyObject *resultobj;
25077     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25078     bool arg2 ;
25079     PyObject * obj0 = 0 ;
25080     PyObject * obj1 = 0 ;
25081     char *kwnames[] = {
25082         (char *) "self",(char *) "p", NULL
25083     };
25084
25085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetIsPreview",kwnames,&obj0,&obj1)) goto fail;
25086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25087     if (SWIG_arg_fail(1)) SWIG_fail;
25088     {
25089         arg2 = (bool)(SWIG_As_bool(obj1));
25090         if (SWIG_arg_fail(2)) SWIG_fail;
25091     }
25092     {
25093         PyThreadState* __tstate = wxPyBeginAllowThreads();
25094         (arg1)->SetIsPreview(arg2);
25095
25096         wxPyEndAllowThreads(__tstate);
25097         if (PyErr_Occurred()) SWIG_fail;
25098     }
25099     Py_INCREF(Py_None); resultobj = Py_None;
25100     return resultobj;
25101     fail:
25102     return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_Printout_base_OnBeginDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25107     PyObject *resultobj;
25108     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25109     int arg2 ;
25110     int arg3 ;
25111     bool result;
25112     PyObject * obj0 = 0 ;
25113     PyObject * obj1 = 0 ;
25114     PyObject * obj2 = 0 ;
25115     char *kwnames[] = {
25116         (char *) "self",(char *) "startPage",(char *) "endPage", NULL
25117     };
25118
25119     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_base_OnBeginDocument",kwnames,&obj0,&obj1,&obj2)) goto fail;
25120     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25121     if (SWIG_arg_fail(1)) SWIG_fail;
25122     {
25123         arg2 = (int)(SWIG_As_int(obj1));
25124         if (SWIG_arg_fail(2)) SWIG_fail;
25125     }
25126     {
25127         arg3 = (int)(SWIG_As_int(obj2));
25128         if (SWIG_arg_fail(3)) SWIG_fail;
25129     }
25130     {
25131         PyThreadState* __tstate = wxPyBeginAllowThreads();
25132         result = (bool)(arg1)->base_OnBeginDocument(arg2,arg3);
25133
25134         wxPyEndAllowThreads(__tstate);
25135         if (PyErr_Occurred()) SWIG_fail;
25136     }
25137     {
25138         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139     }
25140     return resultobj;
25141     fail:
25142     return NULL;
25143 }
25144
25145
25146 static PyObject *_wrap_Printout_base_OnEndDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25147     PyObject *resultobj;
25148     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25149     PyObject * obj0 = 0 ;
25150     char *kwnames[] = {
25151         (char *) "self", NULL
25152     };
25153
25154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndDocument",kwnames,&obj0)) goto fail;
25155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25156     if (SWIG_arg_fail(1)) SWIG_fail;
25157     {
25158         PyThreadState* __tstate = wxPyBeginAllowThreads();
25159         (arg1)->base_OnEndDocument();
25160
25161         wxPyEndAllowThreads(__tstate);
25162         if (PyErr_Occurred()) SWIG_fail;
25163     }
25164     Py_INCREF(Py_None); resultobj = Py_None;
25165     return resultobj;
25166     fail:
25167     return NULL;
25168 }
25169
25170
25171 static PyObject *_wrap_Printout_base_OnBeginPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25172     PyObject *resultobj;
25173     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25174     PyObject * obj0 = 0 ;
25175     char *kwnames[] = {
25176         (char *) "self", NULL
25177     };
25178
25179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnBeginPrinting",kwnames,&obj0)) goto fail;
25180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25181     if (SWIG_arg_fail(1)) SWIG_fail;
25182     {
25183         PyThreadState* __tstate = wxPyBeginAllowThreads();
25184         (arg1)->base_OnBeginPrinting();
25185
25186         wxPyEndAllowThreads(__tstate);
25187         if (PyErr_Occurred()) SWIG_fail;
25188     }
25189     Py_INCREF(Py_None); resultobj = Py_None;
25190     return resultobj;
25191     fail:
25192     return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_Printout_base_OnEndPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25197     PyObject *resultobj;
25198     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25199     PyObject * obj0 = 0 ;
25200     char *kwnames[] = {
25201         (char *) "self", NULL
25202     };
25203
25204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndPrinting",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         (arg1)->base_OnEndPrinting();
25210
25211         wxPyEndAllowThreads(__tstate);
25212         if (PyErr_Occurred()) SWIG_fail;
25213     }
25214     Py_INCREF(Py_None); resultobj = Py_None;
25215     return resultobj;
25216     fail:
25217     return NULL;
25218 }
25219
25220
25221 static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25222     PyObject *resultobj;
25223     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25224     PyObject * obj0 = 0 ;
25225     char *kwnames[] = {
25226         (char *) "self", NULL
25227     };
25228
25229     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnPreparePrinting",kwnames,&obj0)) goto fail;
25230     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25231     if (SWIG_arg_fail(1)) SWIG_fail;
25232     {
25233         PyThreadState* __tstate = wxPyBeginAllowThreads();
25234         (arg1)->base_OnPreparePrinting();
25235
25236         wxPyEndAllowThreads(__tstate);
25237         if (PyErr_Occurred()) SWIG_fail;
25238     }
25239     Py_INCREF(Py_None); resultobj = Py_None;
25240     return resultobj;
25241     fail:
25242     return NULL;
25243 }
25244
25245
25246 static PyObject *_wrap_Printout_base_HasPage(PyObject *, PyObject *args, PyObject *kwargs) {
25247     PyObject *resultobj;
25248     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25249     int arg2 ;
25250     bool result;
25251     PyObject * obj0 = 0 ;
25252     PyObject * obj1 = 0 ;
25253     char *kwnames[] = {
25254         (char *) "self",(char *) "page", NULL
25255     };
25256
25257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_base_HasPage",kwnames,&obj0,&obj1)) goto fail;
25258     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25259     if (SWIG_arg_fail(1)) SWIG_fail;
25260     {
25261         arg2 = (int)(SWIG_As_int(obj1));
25262         if (SWIG_arg_fail(2)) SWIG_fail;
25263     }
25264     {
25265         PyThreadState* __tstate = wxPyBeginAllowThreads();
25266         result = (bool)(arg1)->base_HasPage(arg2);
25267
25268         wxPyEndAllowThreads(__tstate);
25269         if (PyErr_Occurred()) SWIG_fail;
25270     }
25271     {
25272         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25273     }
25274     return resultobj;
25275     fail:
25276     return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
25281     PyObject *resultobj;
25282     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25283     int *arg2 = (int *) 0 ;
25284     int *arg3 = (int *) 0 ;
25285     int *arg4 = (int *) 0 ;
25286     int *arg5 = (int *) 0 ;
25287     int temp2 ;
25288     int res2 = 0 ;
25289     int temp3 ;
25290     int res3 = 0 ;
25291     int temp4 ;
25292     int res4 = 0 ;
25293     int temp5 ;
25294     int res5 = 0 ;
25295     PyObject * obj0 = 0 ;
25296     char *kwnames[] = {
25297         (char *) "self", NULL
25298     };
25299
25300     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25301     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25302     arg4 = &temp4; res4 = SWIG_NEWOBJ;
25303     arg5 = &temp5; res5 = SWIG_NEWOBJ;
25304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_GetPageInfo",kwnames,&obj0)) goto fail;
25305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25306     if (SWIG_arg_fail(1)) SWIG_fail;
25307     {
25308         PyThreadState* __tstate = wxPyBeginAllowThreads();
25309         (arg1)->base_GetPageInfo(arg2,arg3,arg4,arg5);
25310
25311         wxPyEndAllowThreads(__tstate);
25312         if (PyErr_Occurred()) SWIG_fail;
25313     }
25314     Py_INCREF(Py_None); resultobj = Py_None;
25315     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25316     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25317     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25318     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25319     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
25320     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
25321     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
25322     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
25323     return resultobj;
25324     fail:
25325     return NULL;
25326 }
25327
25328
25329 static PyObject * Printout_swigregister(PyObject *, PyObject *args) {
25330     PyObject *obj;
25331     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25332     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintout, obj);
25333     Py_INCREF(obj);
25334     return Py_BuildValue((char *)"");
25335 }
25336 static PyObject *_wrap_new_PreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25337     PyObject *resultobj;
25338     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25339     wxWindow *arg2 = (wxWindow *) 0 ;
25340     wxPoint const &arg3_defvalue = wxDefaultPosition ;
25341     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25342     wxSize const &arg4_defvalue = wxDefaultSize ;
25343     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25344     long arg5 = (long) 0 ;
25345     wxString const &arg6_defvalue = wxPyPreviewCanvasNameStr ;
25346     wxString *arg6 = (wxString *) &arg6_defvalue ;
25347     wxPreviewCanvas *result;
25348     wxPoint temp3 ;
25349     wxSize temp4 ;
25350     bool temp6 = false ;
25351     PyObject * obj0 = 0 ;
25352     PyObject * obj1 = 0 ;
25353     PyObject * obj2 = 0 ;
25354     PyObject * obj3 = 0 ;
25355     PyObject * obj4 = 0 ;
25356     PyObject * obj5 = 0 ;
25357     char *kwnames[] = {
25358         (char *) "preview",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25359     };
25360
25361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PreviewCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25362     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25363     if (SWIG_arg_fail(1)) SWIG_fail;
25364     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25365     if (SWIG_arg_fail(2)) SWIG_fail;
25366     if (obj2) {
25367         {
25368             arg3 = &temp3;
25369             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25370         }
25371     }
25372     if (obj3) {
25373         {
25374             arg4 = &temp4;
25375             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25376         }
25377     }
25378     if (obj4) {
25379         {
25380             arg5 = (long)(SWIG_As_long(obj4));
25381             if (SWIG_arg_fail(5)) SWIG_fail;
25382         }
25383     }
25384     if (obj5) {
25385         {
25386             arg6 = wxString_in_helper(obj5);
25387             if (arg6 == NULL) SWIG_fail;
25388             temp6 = true;
25389         }
25390     }
25391     {
25392         if (!wxPyCheckForApp()) SWIG_fail;
25393         PyThreadState* __tstate = wxPyBeginAllowThreads();
25394         result = (wxPreviewCanvas *)new wxPreviewCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25395
25396         wxPyEndAllowThreads(__tstate);
25397         if (PyErr_Occurred()) SWIG_fail;
25398     }
25399     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 1);
25400     {
25401         if (temp6)
25402         delete arg6;
25403     }
25404     return resultobj;
25405     fail:
25406     {
25407         if (temp6)
25408         delete arg6;
25409     }
25410     return NULL;
25411 }
25412
25413
25414 static PyObject * PreviewCanvas_swigregister(PyObject *, PyObject *args) {
25415     PyObject *obj;
25416     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25417     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewCanvas, obj);
25418     Py_INCREF(obj);
25419     return Py_BuildValue((char *)"");
25420 }
25421 static PyObject *_wrap_new_PreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
25422     PyObject *resultobj;
25423     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25424     wxFrame *arg2 = (wxFrame *) 0 ;
25425     wxString *arg3 = 0 ;
25426     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25427     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25428     wxSize const &arg5_defvalue = wxDefaultSize ;
25429     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25430     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
25431     wxString const &arg7_defvalue = wxPyFrameNameStr ;
25432     wxString *arg7 = (wxString *) &arg7_defvalue ;
25433     wxPreviewFrame *result;
25434     bool temp3 = false ;
25435     wxPoint temp4 ;
25436     wxSize temp5 ;
25437     bool temp7 = false ;
25438     PyObject * obj0 = 0 ;
25439     PyObject * obj1 = 0 ;
25440     PyObject * obj2 = 0 ;
25441     PyObject * obj3 = 0 ;
25442     PyObject * obj4 = 0 ;
25443     PyObject * obj5 = 0 ;
25444     PyObject * obj6 = 0 ;
25445     char *kwnames[] = {
25446         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25447     };
25448
25449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25451     if (SWIG_arg_fail(1)) SWIG_fail;
25452     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
25453     if (SWIG_arg_fail(2)) SWIG_fail;
25454     {
25455         arg3 = wxString_in_helper(obj2);
25456         if (arg3 == NULL) SWIG_fail;
25457         temp3 = true;
25458     }
25459     if (obj3) {
25460         {
25461             arg4 = &temp4;
25462             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25463         }
25464     }
25465     if (obj4) {
25466         {
25467             arg5 = &temp5;
25468             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25469         }
25470     }
25471     if (obj5) {
25472         {
25473             arg6 = (long)(SWIG_As_long(obj5));
25474             if (SWIG_arg_fail(6)) SWIG_fail;
25475         }
25476     }
25477     if (obj6) {
25478         {
25479             arg7 = wxString_in_helper(obj6);
25480             if (arg7 == NULL) SWIG_fail;
25481             temp7 = true;
25482         }
25483     }
25484     {
25485         if (!wxPyCheckForApp()) SWIG_fail;
25486         PyThreadState* __tstate = wxPyBeginAllowThreads();
25487         result = (wxPreviewFrame *)new wxPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25488
25489         wxPyEndAllowThreads(__tstate);
25490         if (PyErr_Occurred()) SWIG_fail;
25491     }
25492     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewFrame, 1);
25493     {
25494         if (temp3)
25495         delete arg3;
25496     }
25497     {
25498         if (temp7)
25499         delete arg7;
25500     }
25501     return resultobj;
25502     fail:
25503     {
25504         if (temp3)
25505         delete arg3;
25506     }
25507     {
25508         if (temp7)
25509         delete arg7;
25510     }
25511     return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_PreviewFrame_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
25516     PyObject *resultobj;
25517     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25518     PyObject * obj0 = 0 ;
25519     char *kwnames[] = {
25520         (char *) "self", NULL
25521     };
25522
25523     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_Initialize",kwnames,&obj0)) goto fail;
25524     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25525     if (SWIG_arg_fail(1)) SWIG_fail;
25526     {
25527         PyThreadState* __tstate = wxPyBeginAllowThreads();
25528         (arg1)->Initialize();
25529
25530         wxPyEndAllowThreads(__tstate);
25531         if (PyErr_Occurred()) SWIG_fail;
25532     }
25533     Py_INCREF(Py_None); resultobj = Py_None;
25534     return resultobj;
25535     fail:
25536     return NULL;
25537 }
25538
25539
25540 static PyObject *_wrap_PreviewFrame_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25541     PyObject *resultobj;
25542     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25543     PyObject * obj0 = 0 ;
25544     char *kwnames[] = {
25545         (char *) "self", NULL
25546     };
25547
25548     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateControlBar",kwnames,&obj0)) goto fail;
25549     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25550     if (SWIG_arg_fail(1)) SWIG_fail;
25551     {
25552         PyThreadState* __tstate = wxPyBeginAllowThreads();
25553         (arg1)->CreateControlBar();
25554
25555         wxPyEndAllowThreads(__tstate);
25556         if (PyErr_Occurred()) SWIG_fail;
25557     }
25558     Py_INCREF(Py_None); resultobj = Py_None;
25559     return resultobj;
25560     fail:
25561     return NULL;
25562 }
25563
25564
25565 static PyObject *_wrap_PreviewFrame_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25566     PyObject *resultobj;
25567     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25568     PyObject * obj0 = 0 ;
25569     char *kwnames[] = {
25570         (char *) "self", NULL
25571     };
25572
25573     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateCanvas",kwnames,&obj0)) goto fail;
25574     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25575     if (SWIG_arg_fail(1)) SWIG_fail;
25576     {
25577         PyThreadState* __tstate = wxPyBeginAllowThreads();
25578         (arg1)->CreateCanvas();
25579
25580         wxPyEndAllowThreads(__tstate);
25581         if (PyErr_Occurred()) SWIG_fail;
25582     }
25583     Py_INCREF(Py_None); resultobj = Py_None;
25584     return resultobj;
25585     fail:
25586     return NULL;
25587 }
25588
25589
25590 static PyObject *_wrap_PreviewFrame_GetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25591     PyObject *resultobj;
25592     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25593     wxPreviewControlBar *result;
25594     PyObject * obj0 = 0 ;
25595     char *kwnames[] = {
25596         (char *) "self", NULL
25597     };
25598
25599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_GetControlBar",kwnames,&obj0)) goto fail;
25600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25601     if (SWIG_arg_fail(1)) SWIG_fail;
25602     {
25603         PyThreadState* __tstate = wxPyBeginAllowThreads();
25604         result = (wxPreviewControlBar *)((wxPreviewFrame const *)arg1)->GetControlBar();
25605
25606         wxPyEndAllowThreads(__tstate);
25607         if (PyErr_Occurred()) SWIG_fail;
25608     }
25609     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 0);
25610     return resultobj;
25611     fail:
25612     return NULL;
25613 }
25614
25615
25616 static PyObject * PreviewFrame_swigregister(PyObject *, PyObject *args) {
25617     PyObject *obj;
25618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25619     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewFrame, obj);
25620     Py_INCREF(obj);
25621     return Py_BuildValue((char *)"");
25622 }
25623 static PyObject *_wrap_new_PreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25624     PyObject *resultobj;
25625     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25626     long arg2 ;
25627     wxWindow *arg3 = (wxWindow *) 0 ;
25628     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25629     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25630     wxSize const &arg5_defvalue = wxDefaultSize ;
25631     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25632     long arg6 = (long) wxTAB_TRAVERSAL ;
25633     wxString const &arg7_defvalue = wxPyPanelNameStr ;
25634     wxString *arg7 = (wxString *) &arg7_defvalue ;
25635     wxPreviewControlBar *result;
25636     wxPoint temp4 ;
25637     wxSize temp5 ;
25638     bool temp7 = false ;
25639     PyObject * obj0 = 0 ;
25640     PyObject * obj1 = 0 ;
25641     PyObject * obj2 = 0 ;
25642     PyObject * obj3 = 0 ;
25643     PyObject * obj4 = 0 ;
25644     PyObject * obj5 = 0 ;
25645     PyObject * obj6 = 0 ;
25646     char *kwnames[] = {
25647         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25648     };
25649
25650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25652     if (SWIG_arg_fail(1)) SWIG_fail;
25653     {
25654         arg2 = (long)(SWIG_As_long(obj1));
25655         if (SWIG_arg_fail(2)) SWIG_fail;
25656     }
25657     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25658     if (SWIG_arg_fail(3)) SWIG_fail;
25659     if (obj3) {
25660         {
25661             arg4 = &temp4;
25662             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25663         }
25664     }
25665     if (obj4) {
25666         {
25667             arg5 = &temp5;
25668             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25669         }
25670     }
25671     if (obj5) {
25672         {
25673             arg6 = (long)(SWIG_As_long(obj5));
25674             if (SWIG_arg_fail(6)) SWIG_fail;
25675         }
25676     }
25677     if (obj6) {
25678         {
25679             arg7 = wxString_in_helper(obj6);
25680             if (arg7 == NULL) SWIG_fail;
25681             temp7 = true;
25682         }
25683     }
25684     {
25685         if (!wxPyCheckForApp()) SWIG_fail;
25686         PyThreadState* __tstate = wxPyBeginAllowThreads();
25687         result = (wxPreviewControlBar *)new wxPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25688
25689         wxPyEndAllowThreads(__tstate);
25690         if (PyErr_Occurred()) SWIG_fail;
25691     }
25692     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 1);
25693     {
25694         if (temp7)
25695         delete arg7;
25696     }
25697     return resultobj;
25698     fail:
25699     {
25700         if (temp7)
25701         delete arg7;
25702     }
25703     return NULL;
25704 }
25705
25706
25707 static PyObject *_wrap_PreviewControlBar_GetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25708     PyObject *resultobj;
25709     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25710     int result;
25711     PyObject * obj0 = 0 ;
25712     char *kwnames[] = {
25713         (char *) "self", NULL
25714     };
25715
25716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetZoomControl",kwnames,&obj0)) goto fail;
25717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25718     if (SWIG_arg_fail(1)) SWIG_fail;
25719     {
25720         PyThreadState* __tstate = wxPyBeginAllowThreads();
25721         result = (int)(arg1)->GetZoomControl();
25722
25723         wxPyEndAllowThreads(__tstate);
25724         if (PyErr_Occurred()) SWIG_fail;
25725     }
25726     {
25727         resultobj = SWIG_From_int((int)(result));
25728     }
25729     return resultobj;
25730     fail:
25731     return NULL;
25732 }
25733
25734
25735 static PyObject *_wrap_PreviewControlBar_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25736     PyObject *resultobj;
25737     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25738     int arg2 ;
25739     PyObject * obj0 = 0 ;
25740     PyObject * obj1 = 0 ;
25741     char *kwnames[] = {
25742         (char *) "self",(char *) "zoom", NULL
25743     };
25744
25745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PreviewControlBar_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
25746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25747     if (SWIG_arg_fail(1)) SWIG_fail;
25748     {
25749         arg2 = (int)(SWIG_As_int(obj1));
25750         if (SWIG_arg_fail(2)) SWIG_fail;
25751     }
25752     {
25753         PyThreadState* __tstate = wxPyBeginAllowThreads();
25754         (arg1)->SetZoomControl(arg2);
25755
25756         wxPyEndAllowThreads(__tstate);
25757         if (PyErr_Occurred()) SWIG_fail;
25758     }
25759     Py_INCREF(Py_None); resultobj = Py_None;
25760     return resultobj;
25761     fail:
25762     return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_PreviewControlBar_GetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25767     PyObject *resultobj;
25768     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25769     wxPrintPreview *result;
25770     PyObject * obj0 = 0 ;
25771     char *kwnames[] = {
25772         (char *) "self", NULL
25773     };
25774
25775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetPrintPreview",kwnames,&obj0)) goto fail;
25776     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25777     if (SWIG_arg_fail(1)) SWIG_fail;
25778     {
25779         PyThreadState* __tstate = wxPyBeginAllowThreads();
25780         result = (wxPrintPreview *)(arg1)->GetPrintPreview();
25781
25782         wxPyEndAllowThreads(__tstate);
25783         if (PyErr_Occurred()) SWIG_fail;
25784     }
25785     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 0);
25786     return resultobj;
25787     fail:
25788     return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_PreviewControlBar_OnNext(PyObject *, PyObject *args, PyObject *kwargs) {
25793     PyObject *resultobj;
25794     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25795     PyObject * obj0 = 0 ;
25796     char *kwnames[] = {
25797         (char *) "self", NULL
25798     };
25799
25800     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnNext",kwnames,&obj0)) goto fail;
25801     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25802     if (SWIG_arg_fail(1)) SWIG_fail;
25803     {
25804         PyThreadState* __tstate = wxPyBeginAllowThreads();
25805         (arg1)->OnNext();
25806
25807         wxPyEndAllowThreads(__tstate);
25808         if (PyErr_Occurred()) SWIG_fail;
25809     }
25810     Py_INCREF(Py_None); resultobj = Py_None;
25811     return resultobj;
25812     fail:
25813     return NULL;
25814 }
25815
25816
25817 static PyObject *_wrap_PreviewControlBar_OnPrevious(PyObject *, PyObject *args, PyObject *kwargs) {
25818     PyObject *resultobj;
25819     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25820     PyObject * obj0 = 0 ;
25821     char *kwnames[] = {
25822         (char *) "self", NULL
25823     };
25824
25825     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnPrevious",kwnames,&obj0)) goto fail;
25826     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25827     if (SWIG_arg_fail(1)) SWIG_fail;
25828     {
25829         PyThreadState* __tstate = wxPyBeginAllowThreads();
25830         (arg1)->OnPrevious();
25831
25832         wxPyEndAllowThreads(__tstate);
25833         if (PyErr_Occurred()) SWIG_fail;
25834     }
25835     Py_INCREF(Py_None); resultobj = Py_None;
25836     return resultobj;
25837     fail:
25838     return NULL;
25839 }
25840
25841
25842 static PyObject *_wrap_PreviewControlBar_OnFirst(PyObject *, PyObject *args, PyObject *kwargs) {
25843     PyObject *resultobj;
25844     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25845     PyObject * obj0 = 0 ;
25846     char *kwnames[] = {
25847         (char *) "self", NULL
25848     };
25849
25850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnFirst",kwnames,&obj0)) goto fail;
25851     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25852     if (SWIG_arg_fail(1)) SWIG_fail;
25853     {
25854         PyThreadState* __tstate = wxPyBeginAllowThreads();
25855         (arg1)->OnFirst();
25856
25857         wxPyEndAllowThreads(__tstate);
25858         if (PyErr_Occurred()) SWIG_fail;
25859     }
25860     Py_INCREF(Py_None); resultobj = Py_None;
25861     return resultobj;
25862     fail:
25863     return NULL;
25864 }
25865
25866
25867 static PyObject *_wrap_PreviewControlBar_OnLast(PyObject *, PyObject *args, PyObject *kwargs) {
25868     PyObject *resultobj;
25869     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25870     PyObject * obj0 = 0 ;
25871     char *kwnames[] = {
25872         (char *) "self", NULL
25873     };
25874
25875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnLast",kwnames,&obj0)) goto fail;
25876     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25877     if (SWIG_arg_fail(1)) SWIG_fail;
25878     {
25879         PyThreadState* __tstate = wxPyBeginAllowThreads();
25880         (arg1)->OnLast();
25881
25882         wxPyEndAllowThreads(__tstate);
25883         if (PyErr_Occurred()) SWIG_fail;
25884     }
25885     Py_INCREF(Py_None); resultobj = Py_None;
25886     return resultobj;
25887     fail:
25888     return NULL;
25889 }
25890
25891
25892 static PyObject *_wrap_PreviewControlBar_OnGoto(PyObject *, PyObject *args, PyObject *kwargs) {
25893     PyObject *resultobj;
25894     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25895     PyObject * obj0 = 0 ;
25896     char *kwnames[] = {
25897         (char *) "self", NULL
25898     };
25899
25900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnGoto",kwnames,&obj0)) goto fail;
25901     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25902     if (SWIG_arg_fail(1)) SWIG_fail;
25903     {
25904         PyThreadState* __tstate = wxPyBeginAllowThreads();
25905         (arg1)->OnGoto();
25906
25907         wxPyEndAllowThreads(__tstate);
25908         if (PyErr_Occurred()) SWIG_fail;
25909     }
25910     Py_INCREF(Py_None); resultobj = Py_None;
25911     return resultobj;
25912     fail:
25913     return NULL;
25914 }
25915
25916
25917 static PyObject * PreviewControlBar_swigregister(PyObject *, PyObject *args) {
25918     PyObject *obj;
25919     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25920     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewControlBar, obj);
25921     Py_INCREF(obj);
25922     return Py_BuildValue((char *)"");
25923 }
25924 static PyObject *_wrap_new_PrintPreview__SWIG_0(PyObject *, PyObject *args) {
25925     PyObject *resultobj;
25926     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25927     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25928     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
25929     wxPrintPreview *result;
25930     PyObject * obj0 = 0 ;
25931     PyObject * obj1 = 0 ;
25932     PyObject * obj2 = 0 ;
25933
25934     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25936     if (SWIG_arg_fail(1)) SWIG_fail;
25937     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25938     if (SWIG_arg_fail(2)) SWIG_fail;
25939     if (obj2) {
25940         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
25941         if (SWIG_arg_fail(3)) SWIG_fail;
25942     }
25943     {
25944         if (!wxPyCheckForApp()) SWIG_fail;
25945         PyThreadState* __tstate = wxPyBeginAllowThreads();
25946         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25947
25948         wxPyEndAllowThreads(__tstate);
25949         if (PyErr_Occurred()) SWIG_fail;
25950     }
25951     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25952     return resultobj;
25953     fail:
25954     return NULL;
25955 }
25956
25957
25958 static PyObject *_wrap_new_PrintPreview__SWIG_1(PyObject *, PyObject *args) {
25959     PyObject *resultobj;
25960     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25961     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25962     wxPrintData *arg3 = (wxPrintData *) 0 ;
25963     wxPrintPreview *result;
25964     PyObject * obj0 = 0 ;
25965     PyObject * obj1 = 0 ;
25966     PyObject * obj2 = 0 ;
25967
25968     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25969     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25970     if (SWIG_arg_fail(1)) SWIG_fail;
25971     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25972     if (SWIG_arg_fail(2)) SWIG_fail;
25973     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
25974     if (SWIG_arg_fail(3)) SWIG_fail;
25975     {
25976         if (!wxPyCheckForApp()) SWIG_fail;
25977         PyThreadState* __tstate = wxPyBeginAllowThreads();
25978         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25979
25980         wxPyEndAllowThreads(__tstate);
25981         if (PyErr_Occurred()) SWIG_fail;
25982     }
25983     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25984     return resultobj;
25985     fail:
25986     return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_new_PrintPreview(PyObject *self, PyObject *args) {
25991     int argc;
25992     PyObject *argv[4];
25993     int ii;
25994
25995     argc = PyObject_Length(args);
25996     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
25997         argv[ii] = PyTuple_GetItem(args,ii);
25998     }
25999     if ((argc >= 2) && (argc <= 3)) {
26000         int _v;
26001         {
26002             void *ptr;
26003             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26004                 _v = 0;
26005                 PyErr_Clear();
26006             } else {
26007                 _v = 1;
26008             }
26009         }
26010         if (_v) {
26011             {
26012                 void *ptr;
26013                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26014                     _v = 0;
26015                     PyErr_Clear();
26016                 } else {
26017                     _v = 1;
26018                 }
26019             }
26020             if (_v) {
26021                 if (argc <= 2) {
26022                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26023                 }
26024                 {
26025                     void *ptr;
26026                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26027                         _v = 0;
26028                         PyErr_Clear();
26029                     } else {
26030                         _v = 1;
26031                     }
26032                 }
26033                 if (_v) {
26034                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26035                 }
26036             }
26037         }
26038     }
26039     if (argc == 3) {
26040         int _v;
26041         {
26042             void *ptr;
26043             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26044                 _v = 0;
26045                 PyErr_Clear();
26046             } else {
26047                 _v = 1;
26048             }
26049         }
26050         if (_v) {
26051             {
26052                 void *ptr;
26053                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26054                     _v = 0;
26055                     PyErr_Clear();
26056                 } else {
26057                     _v = 1;
26058                 }
26059             }
26060             if (_v) {
26061                 {
26062                     void *ptr;
26063                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26064                         _v = 0;
26065                         PyErr_Clear();
26066                     } else {
26067                         _v = 1;
26068                     }
26069                 }
26070                 if (_v) {
26071                     return _wrap_new_PrintPreview__SWIG_1(self,args);
26072                 }
26073             }
26074         }
26075     }
26076
26077     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintPreview'");
26078     return NULL;
26079 }
26080
26081
26082 static PyObject *_wrap_PrintPreview_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26083     PyObject *resultobj;
26084     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26085     int arg2 ;
26086     bool result;
26087     PyObject * obj0 = 0 ;
26088     PyObject * obj1 = 0 ;
26089     char *kwnames[] = {
26090         (char *) "self",(char *) "pageNum", NULL
26091     };
26092
26093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26094     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26095     if (SWIG_arg_fail(1)) SWIG_fail;
26096     {
26097         arg2 = (int)(SWIG_As_int(obj1));
26098         if (SWIG_arg_fail(2)) SWIG_fail;
26099     }
26100     {
26101         PyThreadState* __tstate = wxPyBeginAllowThreads();
26102         result = (bool)(arg1)->SetCurrentPage(arg2);
26103
26104         wxPyEndAllowThreads(__tstate);
26105         if (PyErr_Occurred()) SWIG_fail;
26106     }
26107     {
26108         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26109     }
26110     return resultobj;
26111     fail:
26112     return NULL;
26113 }
26114
26115
26116 static PyObject *_wrap_PrintPreview_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26117     PyObject *resultobj;
26118     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26119     int result;
26120     PyObject * obj0 = 0 ;
26121     char *kwnames[] = {
26122         (char *) "self", NULL
26123     };
26124
26125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCurrentPage",kwnames,&obj0)) goto fail;
26126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26127     if (SWIG_arg_fail(1)) SWIG_fail;
26128     {
26129         PyThreadState* __tstate = wxPyBeginAllowThreads();
26130         result = (int)(arg1)->GetCurrentPage();
26131
26132         wxPyEndAllowThreads(__tstate);
26133         if (PyErr_Occurred()) SWIG_fail;
26134     }
26135     {
26136         resultobj = SWIG_From_int((int)(result));
26137     }
26138     return resultobj;
26139     fail:
26140     return NULL;
26141 }
26142
26143
26144 static PyObject *_wrap_PrintPreview_SetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26145     PyObject *resultobj;
26146     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26147     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26148     PyObject * obj0 = 0 ;
26149     PyObject * obj1 = 0 ;
26150     char *kwnames[] = {
26151         (char *) "self",(char *) "printout", NULL
26152     };
26153
26154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetPrintout",kwnames,&obj0,&obj1)) goto fail;
26155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26156     if (SWIG_arg_fail(1)) SWIG_fail;
26157     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26158     if (SWIG_arg_fail(2)) SWIG_fail;
26159     {
26160         PyThreadState* __tstate = wxPyBeginAllowThreads();
26161         (arg1)->SetPrintout(arg2);
26162
26163         wxPyEndAllowThreads(__tstate);
26164         if (PyErr_Occurred()) SWIG_fail;
26165     }
26166     Py_INCREF(Py_None); resultobj = Py_None;
26167     return resultobj;
26168     fail:
26169     return NULL;
26170 }
26171
26172
26173 static PyObject *_wrap_PrintPreview_GetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26174     PyObject *resultobj;
26175     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26176     wxPyPrintout *result;
26177     PyObject * obj0 = 0 ;
26178     char *kwnames[] = {
26179         (char *) "self", NULL
26180     };
26181
26182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintout",kwnames,&obj0)) goto fail;
26183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26184     if (SWIG_arg_fail(1)) SWIG_fail;
26185     {
26186         PyThreadState* __tstate = wxPyBeginAllowThreads();
26187         result = (wxPyPrintout *)(arg1)->GetPrintout();
26188
26189         wxPyEndAllowThreads(__tstate);
26190         if (PyErr_Occurred()) SWIG_fail;
26191     }
26192     {
26193         resultobj = wxPyMake_wxObject(result, 0);
26194     }
26195     return resultobj;
26196     fail:
26197     return NULL;
26198 }
26199
26200
26201 static PyObject *_wrap_PrintPreview_GetPrintoutForPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
26202     PyObject *resultobj;
26203     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26204     wxPyPrintout *result;
26205     PyObject * obj0 = 0 ;
26206     char *kwnames[] = {
26207         (char *) "self", NULL
26208     };
26209
26210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintoutForPrinting",kwnames,&obj0)) goto fail;
26211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26212     if (SWIG_arg_fail(1)) SWIG_fail;
26213     {
26214         PyThreadState* __tstate = wxPyBeginAllowThreads();
26215         result = (wxPyPrintout *)(arg1)->GetPrintoutForPrinting();
26216
26217         wxPyEndAllowThreads(__tstate);
26218         if (PyErr_Occurred()) SWIG_fail;
26219     }
26220     {
26221         resultobj = wxPyMake_wxObject(result, 0);
26222     }
26223     return resultobj;
26224     fail:
26225     return NULL;
26226 }
26227
26228
26229 static PyObject *_wrap_PrintPreview_SetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26230     PyObject *resultobj;
26231     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26232     wxFrame *arg2 = (wxFrame *) 0 ;
26233     PyObject * obj0 = 0 ;
26234     PyObject * obj1 = 0 ;
26235     char *kwnames[] = {
26236         (char *) "self",(char *) "frame", NULL
26237     };
26238
26239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetFrame",kwnames,&obj0,&obj1)) goto fail;
26240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26241     if (SWIG_arg_fail(1)) SWIG_fail;
26242     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
26243     if (SWIG_arg_fail(2)) SWIG_fail;
26244     {
26245         PyThreadState* __tstate = wxPyBeginAllowThreads();
26246         (arg1)->SetFrame(arg2);
26247
26248         wxPyEndAllowThreads(__tstate);
26249         if (PyErr_Occurred()) SWIG_fail;
26250     }
26251     Py_INCREF(Py_None); resultobj = Py_None;
26252     return resultobj;
26253     fail:
26254     return NULL;
26255 }
26256
26257
26258 static PyObject *_wrap_PrintPreview_SetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26259     PyObject *resultobj;
26260     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26261     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26262     PyObject * obj0 = 0 ;
26263     PyObject * obj1 = 0 ;
26264     char *kwnames[] = {
26265         (char *) "self",(char *) "canvas", NULL
26266     };
26267
26268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCanvas",kwnames,&obj0,&obj1)) goto fail;
26269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26270     if (SWIG_arg_fail(1)) SWIG_fail;
26271     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26272     if (SWIG_arg_fail(2)) SWIG_fail;
26273     {
26274         PyThreadState* __tstate = wxPyBeginAllowThreads();
26275         (arg1)->SetCanvas(arg2);
26276
26277         wxPyEndAllowThreads(__tstate);
26278         if (PyErr_Occurred()) SWIG_fail;
26279     }
26280     Py_INCREF(Py_None); resultobj = Py_None;
26281     return resultobj;
26282     fail:
26283     return NULL;
26284 }
26285
26286
26287 static PyObject *_wrap_PrintPreview_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26288     PyObject *resultobj;
26289     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26290     wxFrame *result;
26291     PyObject * obj0 = 0 ;
26292     char *kwnames[] = {
26293         (char *) "self", NULL
26294     };
26295
26296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetFrame",kwnames,&obj0)) goto fail;
26297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26298     if (SWIG_arg_fail(1)) SWIG_fail;
26299     {
26300         PyThreadState* __tstate = wxPyBeginAllowThreads();
26301         result = (wxFrame *)(arg1)->GetFrame();
26302
26303         wxPyEndAllowThreads(__tstate);
26304         if (PyErr_Occurred()) SWIG_fail;
26305     }
26306     {
26307         resultobj = wxPyMake_wxObject(result, 0);
26308     }
26309     return resultobj;
26310     fail:
26311     return NULL;
26312 }
26313
26314
26315 static PyObject *_wrap_PrintPreview_GetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26316     PyObject *resultobj;
26317     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26318     wxPreviewCanvas *result;
26319     PyObject * obj0 = 0 ;
26320     char *kwnames[] = {
26321         (char *) "self", NULL
26322     };
26323
26324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCanvas",kwnames,&obj0)) goto fail;
26325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26326     if (SWIG_arg_fail(1)) SWIG_fail;
26327     {
26328         PyThreadState* __tstate = wxPyBeginAllowThreads();
26329         result = (wxPreviewCanvas *)(arg1)->GetCanvas();
26330
26331         wxPyEndAllowThreads(__tstate);
26332         if (PyErr_Occurred()) SWIG_fail;
26333     }
26334     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 0);
26335     return resultobj;
26336     fail:
26337     return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_PrintPreview_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26342     PyObject *resultobj;
26343     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26344     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26345     wxDC *arg3 = 0 ;
26346     bool result;
26347     PyObject * obj0 = 0 ;
26348     PyObject * obj1 = 0 ;
26349     PyObject * obj2 = 0 ;
26350     char *kwnames[] = {
26351         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26352     };
26353
26354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26356     if (SWIG_arg_fail(1)) SWIG_fail;
26357     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26358     if (SWIG_arg_fail(2)) SWIG_fail;
26359     {
26360         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26361         if (SWIG_arg_fail(3)) SWIG_fail;
26362         if (arg3 == NULL) {
26363             SWIG_null_ref("wxDC");
26364         }
26365         if (SWIG_arg_fail(3)) SWIG_fail;
26366     }
26367     {
26368         PyThreadState* __tstate = wxPyBeginAllowThreads();
26369         result = (bool)(arg1)->PaintPage(arg2,*arg3);
26370
26371         wxPyEndAllowThreads(__tstate);
26372         if (PyErr_Occurred()) SWIG_fail;
26373     }
26374     {
26375         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26376     }
26377     return resultobj;
26378     fail:
26379     return NULL;
26380 }
26381
26382
26383 static PyObject *_wrap_PrintPreview_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26384     PyObject *resultobj;
26385     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26386     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26387     wxDC *arg3 = 0 ;
26388     bool result;
26389     PyObject * obj0 = 0 ;
26390     PyObject * obj1 = 0 ;
26391     PyObject * obj2 = 0 ;
26392     char *kwnames[] = {
26393         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26394     };
26395
26396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26398     if (SWIG_arg_fail(1)) SWIG_fail;
26399     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26400     if (SWIG_arg_fail(2)) SWIG_fail;
26401     {
26402         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26403         if (SWIG_arg_fail(3)) SWIG_fail;
26404         if (arg3 == NULL) {
26405             SWIG_null_ref("wxDC");
26406         }
26407         if (SWIG_arg_fail(3)) SWIG_fail;
26408     }
26409     {
26410         PyThreadState* __tstate = wxPyBeginAllowThreads();
26411         result = (bool)(arg1)->DrawBlankPage(arg2,*arg3);
26412
26413         wxPyEndAllowThreads(__tstate);
26414         if (PyErr_Occurred()) SWIG_fail;
26415     }
26416     {
26417         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26418     }
26419     return resultobj;
26420     fail:
26421     return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_PrintPreview_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
26426     PyObject *resultobj;
26427     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26428     int arg2 ;
26429     bool result;
26430     PyObject * obj0 = 0 ;
26431     PyObject * obj1 = 0 ;
26432     char *kwnames[] = {
26433         (char *) "self",(char *) "pageNum", NULL
26434     };
26435
26436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_RenderPage",kwnames,&obj0,&obj1)) goto fail;
26437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26438     if (SWIG_arg_fail(1)) SWIG_fail;
26439     {
26440         arg2 = (int)(SWIG_As_int(obj1));
26441         if (SWIG_arg_fail(2)) SWIG_fail;
26442     }
26443     {
26444         PyThreadState* __tstate = wxPyBeginAllowThreads();
26445         result = (bool)(arg1)->RenderPage(arg2);
26446
26447         wxPyEndAllowThreads(__tstate);
26448         if (PyErr_Occurred()) SWIG_fail;
26449     }
26450     {
26451         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26452     }
26453     return resultobj;
26454     fail:
26455     return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_PrintPreview_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
26460     PyObject *resultobj;
26461     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26462     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26463     PyObject * obj0 = 0 ;
26464     PyObject * obj1 = 0 ;
26465     char *kwnames[] = {
26466         (char *) "self",(char *) "canvas", NULL
26467     };
26468
26469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_AdjustScrollbars",kwnames,&obj0,&obj1)) goto fail;
26470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26471     if (SWIG_arg_fail(1)) SWIG_fail;
26472     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26473     if (SWIG_arg_fail(2)) SWIG_fail;
26474     {
26475         PyThreadState* __tstate = wxPyBeginAllowThreads();
26476         (arg1)->AdjustScrollbars(arg2);
26477
26478         wxPyEndAllowThreads(__tstate);
26479         if (PyErr_Occurred()) SWIG_fail;
26480     }
26481     Py_INCREF(Py_None); resultobj = Py_None;
26482     return resultobj;
26483     fail:
26484     return NULL;
26485 }
26486
26487
26488 static PyObject *_wrap_PrintPreview_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
26489     PyObject *resultobj;
26490     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26491     wxPrintDialogData *result;
26492     PyObject * obj0 = 0 ;
26493     char *kwnames[] = {
26494         (char *) "self", NULL
26495     };
26496
26497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintDialogData",kwnames,&obj0)) goto fail;
26498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26499     if (SWIG_arg_fail(1)) SWIG_fail;
26500     {
26501         PyThreadState* __tstate = wxPyBeginAllowThreads();
26502         {
26503             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
26504             result = (wxPrintDialogData *) &_result_ref;
26505         }
26506
26507         wxPyEndAllowThreads(__tstate);
26508         if (PyErr_Occurred()) SWIG_fail;
26509     }
26510     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
26511     return resultobj;
26512     fail:
26513     return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_PrintPreview_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26518     PyObject *resultobj;
26519     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26520     int arg2 ;
26521     PyObject * obj0 = 0 ;
26522     PyObject * obj1 = 0 ;
26523     char *kwnames[] = {
26524         (char *) "self",(char *) "percent", NULL
26525     };
26526
26527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetZoom",kwnames,&obj0,&obj1)) goto fail;
26528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26529     if (SWIG_arg_fail(1)) SWIG_fail;
26530     {
26531         arg2 = (int)(SWIG_As_int(obj1));
26532         if (SWIG_arg_fail(2)) SWIG_fail;
26533     }
26534     {
26535         PyThreadState* __tstate = wxPyBeginAllowThreads();
26536         (arg1)->SetZoom(arg2);
26537
26538         wxPyEndAllowThreads(__tstate);
26539         if (PyErr_Occurred()) SWIG_fail;
26540     }
26541     Py_INCREF(Py_None); resultobj = Py_None;
26542     return resultobj;
26543     fail:
26544     return NULL;
26545 }
26546
26547
26548 static PyObject *_wrap_PrintPreview_GetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26549     PyObject *resultobj;
26550     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26551     int result;
26552     PyObject * obj0 = 0 ;
26553     char *kwnames[] = {
26554         (char *) "self", NULL
26555     };
26556
26557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetZoom",kwnames,&obj0)) goto fail;
26558     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26559     if (SWIG_arg_fail(1)) SWIG_fail;
26560     {
26561         PyThreadState* __tstate = wxPyBeginAllowThreads();
26562         result = (int)(arg1)->GetZoom();
26563
26564         wxPyEndAllowThreads(__tstate);
26565         if (PyErr_Occurred()) SWIG_fail;
26566     }
26567     {
26568         resultobj = SWIG_From_int((int)(result));
26569     }
26570     return resultobj;
26571     fail:
26572     return NULL;
26573 }
26574
26575
26576 static PyObject *_wrap_PrintPreview_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
26577     PyObject *resultobj;
26578     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26579     int result;
26580     PyObject * obj0 = 0 ;
26581     char *kwnames[] = {
26582         (char *) "self", NULL
26583     };
26584
26585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMaxPage",kwnames,&obj0)) goto fail;
26586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26587     if (SWIG_arg_fail(1)) SWIG_fail;
26588     {
26589         PyThreadState* __tstate = wxPyBeginAllowThreads();
26590         result = (int)(arg1)->GetMaxPage();
26591
26592         wxPyEndAllowThreads(__tstate);
26593         if (PyErr_Occurred()) SWIG_fail;
26594     }
26595     {
26596         resultobj = SWIG_From_int((int)(result));
26597     }
26598     return resultobj;
26599     fail:
26600     return NULL;
26601 }
26602
26603
26604 static PyObject *_wrap_PrintPreview_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
26605     PyObject *resultobj;
26606     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26607     int result;
26608     PyObject * obj0 = 0 ;
26609     char *kwnames[] = {
26610         (char *) "self", NULL
26611     };
26612
26613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMinPage",kwnames,&obj0)) goto fail;
26614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26615     if (SWIG_arg_fail(1)) SWIG_fail;
26616     {
26617         PyThreadState* __tstate = wxPyBeginAllowThreads();
26618         result = (int)(arg1)->GetMinPage();
26619
26620         wxPyEndAllowThreads(__tstate);
26621         if (PyErr_Occurred()) SWIG_fail;
26622     }
26623     {
26624         resultobj = SWIG_From_int((int)(result));
26625     }
26626     return resultobj;
26627     fail:
26628     return NULL;
26629 }
26630
26631
26632 static PyObject *_wrap_PrintPreview_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
26633     PyObject *resultobj;
26634     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26635     bool result;
26636     PyObject * obj0 = 0 ;
26637     char *kwnames[] = {
26638         (char *) "self", NULL
26639     };
26640
26641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_Ok",kwnames,&obj0)) goto fail;
26642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26643     if (SWIG_arg_fail(1)) SWIG_fail;
26644     {
26645         PyThreadState* __tstate = wxPyBeginAllowThreads();
26646         result = (bool)(arg1)->Ok();
26647
26648         wxPyEndAllowThreads(__tstate);
26649         if (PyErr_Occurred()) SWIG_fail;
26650     }
26651     {
26652         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26653     }
26654     return resultobj;
26655     fail:
26656     return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_PrintPreview_SetOk(PyObject *, PyObject *args, PyObject *kwargs) {
26661     PyObject *resultobj;
26662     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26663     bool arg2 ;
26664     PyObject * obj0 = 0 ;
26665     PyObject * obj1 = 0 ;
26666     char *kwnames[] = {
26667         (char *) "self",(char *) "ok", NULL
26668     };
26669
26670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetOk",kwnames,&obj0,&obj1)) goto fail;
26671     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26672     if (SWIG_arg_fail(1)) SWIG_fail;
26673     {
26674         arg2 = (bool)(SWIG_As_bool(obj1));
26675         if (SWIG_arg_fail(2)) SWIG_fail;
26676     }
26677     {
26678         PyThreadState* __tstate = wxPyBeginAllowThreads();
26679         (arg1)->SetOk(arg2);
26680
26681         wxPyEndAllowThreads(__tstate);
26682         if (PyErr_Occurred()) SWIG_fail;
26683     }
26684     Py_INCREF(Py_None); resultobj = Py_None;
26685     return resultobj;
26686     fail:
26687     return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_PrintPreview_Print(PyObject *, PyObject *args, PyObject *kwargs) {
26692     PyObject *resultobj;
26693     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26694     bool arg2 ;
26695     bool result;
26696     PyObject * obj0 = 0 ;
26697     PyObject * obj1 = 0 ;
26698     char *kwnames[] = {
26699         (char *) "self",(char *) "interactive", NULL
26700     };
26701
26702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_Print",kwnames,&obj0,&obj1)) goto fail;
26703     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26704     if (SWIG_arg_fail(1)) SWIG_fail;
26705     {
26706         arg2 = (bool)(SWIG_As_bool(obj1));
26707         if (SWIG_arg_fail(2)) SWIG_fail;
26708     }
26709     {
26710         PyThreadState* __tstate = wxPyBeginAllowThreads();
26711         result = (bool)(arg1)->Print(arg2);
26712
26713         wxPyEndAllowThreads(__tstate);
26714         if (PyErr_Occurred()) SWIG_fail;
26715     }
26716     {
26717         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26718     }
26719     return resultobj;
26720     fail:
26721     return NULL;
26722 }
26723
26724
26725 static PyObject *_wrap_PrintPreview_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
26726     PyObject *resultobj;
26727     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26728     PyObject * obj0 = 0 ;
26729     char *kwnames[] = {
26730         (char *) "self", NULL
26731     };
26732
26733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_DetermineScaling",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         (arg1)->DetermineScaling();
26739
26740         wxPyEndAllowThreads(__tstate);
26741         if (PyErr_Occurred()) SWIG_fail;
26742     }
26743     Py_INCREF(Py_None); resultobj = Py_None;
26744     return resultobj;
26745     fail:
26746     return NULL;
26747 }
26748
26749
26750 static PyObject * PrintPreview_swigregister(PyObject *, PyObject *args) {
26751     PyObject *obj;
26752     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26753     SWIG_TypeClientData(SWIGTYPE_p_wxPrintPreview, obj);
26754     Py_INCREF(obj);
26755     return Py_BuildValue((char *)"");
26756 }
26757 static PyObject *_wrap_new_PyPrintPreview__SWIG_0(PyObject *, PyObject *args) {
26758     PyObject *resultobj;
26759     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26760     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26761     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26762     wxPyPrintPreview *result;
26763     PyObject * obj0 = 0 ;
26764     PyObject * obj1 = 0 ;
26765     PyObject * obj2 = 0 ;
26766
26767     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26768     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26769     if (SWIG_arg_fail(1)) SWIG_fail;
26770     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26771     if (SWIG_arg_fail(2)) SWIG_fail;
26772     if (obj2) {
26773         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26774         if (SWIG_arg_fail(3)) SWIG_fail;
26775     }
26776     {
26777         if (!wxPyCheckForApp()) SWIG_fail;
26778         PyThreadState* __tstate = wxPyBeginAllowThreads();
26779         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26780
26781         wxPyEndAllowThreads(__tstate);
26782         if (PyErr_Occurred()) SWIG_fail;
26783     }
26784     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26785     return resultobj;
26786     fail:
26787     return NULL;
26788 }
26789
26790
26791 static PyObject *_wrap_new_PyPrintPreview__SWIG_1(PyObject *, PyObject *args) {
26792     PyObject *resultobj;
26793     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26794     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26795     wxPrintData *arg3 = (wxPrintData *) 0 ;
26796     wxPyPrintPreview *result;
26797     PyObject * obj0 = 0 ;
26798     PyObject * obj1 = 0 ;
26799     PyObject * obj2 = 0 ;
26800
26801     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26802     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26803     if (SWIG_arg_fail(1)) SWIG_fail;
26804     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26805     if (SWIG_arg_fail(2)) SWIG_fail;
26806     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26807     if (SWIG_arg_fail(3)) SWIG_fail;
26808     {
26809         if (!wxPyCheckForApp()) SWIG_fail;
26810         PyThreadState* __tstate = wxPyBeginAllowThreads();
26811         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26812
26813         wxPyEndAllowThreads(__tstate);
26814         if (PyErr_Occurred()) SWIG_fail;
26815     }
26816     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26817     return resultobj;
26818     fail:
26819     return NULL;
26820 }
26821
26822
26823 static PyObject *_wrap_new_PyPrintPreview(PyObject *self, PyObject *args) {
26824     int argc;
26825     PyObject *argv[4];
26826     int ii;
26827
26828     argc = PyObject_Length(args);
26829     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26830         argv[ii] = PyTuple_GetItem(args,ii);
26831     }
26832     if ((argc >= 2) && (argc <= 3)) {
26833         int _v;
26834         {
26835             void *ptr;
26836             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26837                 _v = 0;
26838                 PyErr_Clear();
26839             } else {
26840                 _v = 1;
26841             }
26842         }
26843         if (_v) {
26844             {
26845                 void *ptr;
26846                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26847                     _v = 0;
26848                     PyErr_Clear();
26849                 } else {
26850                     _v = 1;
26851                 }
26852             }
26853             if (_v) {
26854                 if (argc <= 2) {
26855                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26856                 }
26857                 {
26858                     void *ptr;
26859                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26860                         _v = 0;
26861                         PyErr_Clear();
26862                     } else {
26863                         _v = 1;
26864                     }
26865                 }
26866                 if (_v) {
26867                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26868                 }
26869             }
26870         }
26871     }
26872     if (argc == 3) {
26873         int _v;
26874         {
26875             void *ptr;
26876             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26877                 _v = 0;
26878                 PyErr_Clear();
26879             } else {
26880                 _v = 1;
26881             }
26882         }
26883         if (_v) {
26884             {
26885                 void *ptr;
26886                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26887                     _v = 0;
26888                     PyErr_Clear();
26889                 } else {
26890                     _v = 1;
26891                 }
26892             }
26893             if (_v) {
26894                 {
26895                     void *ptr;
26896                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26897                         _v = 0;
26898                         PyErr_Clear();
26899                     } else {
26900                         _v = 1;
26901                     }
26902                 }
26903                 if (_v) {
26904                     return _wrap_new_PyPrintPreview__SWIG_1(self,args);
26905                 }
26906             }
26907         }
26908     }
26909
26910     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PyPrintPreview'");
26911     return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_PyPrintPreview__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
26916     PyObject *resultobj;
26917     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26918     PyObject *arg2 = (PyObject *) 0 ;
26919     PyObject *arg3 = (PyObject *) 0 ;
26920     PyObject * obj0 = 0 ;
26921     PyObject * obj1 = 0 ;
26922     PyObject * obj2 = 0 ;
26923     char *kwnames[] = {
26924         (char *) "self",(char *) "self",(char *) "_class", NULL
26925     };
26926
26927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
26928     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26929     if (SWIG_arg_fail(1)) SWIG_fail;
26930     arg2 = obj1;
26931     arg3 = obj2;
26932     {
26933         PyThreadState* __tstate = wxPyBeginAllowThreads();
26934         (arg1)->_setCallbackInfo(arg2,arg3);
26935
26936         wxPyEndAllowThreads(__tstate);
26937         if (PyErr_Occurred()) SWIG_fail;
26938     }
26939     Py_INCREF(Py_None); resultobj = Py_None;
26940     return resultobj;
26941     fail:
26942     return NULL;
26943 }
26944
26945
26946 static PyObject *_wrap_PyPrintPreview_base_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26947     PyObject *resultobj;
26948     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26949     int arg2 ;
26950     bool result;
26951     PyObject * obj0 = 0 ;
26952     PyObject * obj1 = 0 ;
26953     char *kwnames[] = {
26954         (char *) "self",(char *) "pageNum", NULL
26955     };
26956
26957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26958     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26959     if (SWIG_arg_fail(1)) SWIG_fail;
26960     {
26961         arg2 = (int)(SWIG_As_int(obj1));
26962         if (SWIG_arg_fail(2)) SWIG_fail;
26963     }
26964     {
26965         PyThreadState* __tstate = wxPyBeginAllowThreads();
26966         result = (bool)(arg1)->base_SetCurrentPage(arg2);
26967
26968         wxPyEndAllowThreads(__tstate);
26969         if (PyErr_Occurred()) SWIG_fail;
26970     }
26971     {
26972         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26973     }
26974     return resultobj;
26975     fail:
26976     return NULL;
26977 }
26978
26979
26980 static PyObject *_wrap_PyPrintPreview_base_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26981     PyObject *resultobj;
26982     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26983     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26984     wxDC *arg3 = 0 ;
26985     bool result;
26986     PyObject * obj0 = 0 ;
26987     PyObject * obj1 = 0 ;
26988     PyObject * obj2 = 0 ;
26989     char *kwnames[] = {
26990         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26991     };
26992
26993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26994     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26995     if (SWIG_arg_fail(1)) SWIG_fail;
26996     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26997     if (SWIG_arg_fail(2)) SWIG_fail;
26998     {
26999         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27000         if (SWIG_arg_fail(3)) SWIG_fail;
27001         if (arg3 == NULL) {
27002             SWIG_null_ref("wxDC");
27003         }
27004         if (SWIG_arg_fail(3)) SWIG_fail;
27005     }
27006     {
27007         PyThreadState* __tstate = wxPyBeginAllowThreads();
27008         result = (bool)(arg1)->base_PaintPage(arg2,*arg3);
27009
27010         wxPyEndAllowThreads(__tstate);
27011         if (PyErr_Occurred()) SWIG_fail;
27012     }
27013     {
27014         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27015     }
27016     return resultobj;
27017     fail:
27018     return NULL;
27019 }
27020
27021
27022 static PyObject *_wrap_PyPrintPreview_base_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
27023     PyObject *resultobj;
27024     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27025     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27026     wxDC *arg3 = 0 ;
27027     bool result;
27028     PyObject * obj0 = 0 ;
27029     PyObject * obj1 = 0 ;
27030     PyObject * obj2 = 0 ;
27031     char *kwnames[] = {
27032         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27033     };
27034
27035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27037     if (SWIG_arg_fail(1)) SWIG_fail;
27038     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27039     if (SWIG_arg_fail(2)) SWIG_fail;
27040     {
27041         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27042         if (SWIG_arg_fail(3)) SWIG_fail;
27043         if (arg3 == NULL) {
27044             SWIG_null_ref("wxDC");
27045         }
27046         if (SWIG_arg_fail(3)) SWIG_fail;
27047     }
27048     {
27049         PyThreadState* __tstate = wxPyBeginAllowThreads();
27050         result = (bool)(arg1)->base_DrawBlankPage(arg2,*arg3);
27051
27052         wxPyEndAllowThreads(__tstate);
27053         if (PyErr_Occurred()) SWIG_fail;
27054     }
27055     {
27056         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27057     }
27058     return resultobj;
27059     fail:
27060     return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_PyPrintPreview_base_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
27065     PyObject *resultobj;
27066     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27067     int arg2 ;
27068     bool result;
27069     PyObject * obj0 = 0 ;
27070     PyObject * obj1 = 0 ;
27071     char *kwnames[] = {
27072         (char *) "self",(char *) "pageNum", NULL
27073     };
27074
27075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_RenderPage",kwnames,&obj0,&obj1)) 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     {
27079         arg2 = (int)(SWIG_As_int(obj1));
27080         if (SWIG_arg_fail(2)) SWIG_fail;
27081     }
27082     {
27083         PyThreadState* __tstate = wxPyBeginAllowThreads();
27084         result = (bool)(arg1)->base_RenderPage(arg2);
27085
27086         wxPyEndAllowThreads(__tstate);
27087         if (PyErr_Occurred()) SWIG_fail;
27088     }
27089     {
27090         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27091     }
27092     return resultobj;
27093     fail:
27094     return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_PyPrintPreview_base_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
27099     PyObject *resultobj;
27100     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27101     int arg2 ;
27102     PyObject * obj0 = 0 ;
27103     PyObject * obj1 = 0 ;
27104     char *kwnames[] = {
27105         (char *) "self",(char *) "percent", NULL
27106     };
27107
27108     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetZoom",kwnames,&obj0,&obj1)) goto fail;
27109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27110     if (SWIG_arg_fail(1)) SWIG_fail;
27111     {
27112         arg2 = (int)(SWIG_As_int(obj1));
27113         if (SWIG_arg_fail(2)) SWIG_fail;
27114     }
27115     {
27116         PyThreadState* __tstate = wxPyBeginAllowThreads();
27117         (arg1)->base_SetZoom(arg2);
27118
27119         wxPyEndAllowThreads(__tstate);
27120         if (PyErr_Occurred()) SWIG_fail;
27121     }
27122     Py_INCREF(Py_None); resultobj = Py_None;
27123     return resultobj;
27124     fail:
27125     return NULL;
27126 }
27127
27128
27129 static PyObject *_wrap_PyPrintPreview_base_Print(PyObject *, PyObject *args, PyObject *kwargs) {
27130     PyObject *resultobj;
27131     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27132     bool arg2 ;
27133     bool result;
27134     PyObject * obj0 = 0 ;
27135     PyObject * obj1 = 0 ;
27136     char *kwnames[] = {
27137         (char *) "self",(char *) "interactive", NULL
27138     };
27139
27140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_Print",kwnames,&obj0,&obj1)) goto fail;
27141     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27142     if (SWIG_arg_fail(1)) SWIG_fail;
27143     {
27144         arg2 = (bool)(SWIG_As_bool(obj1));
27145         if (SWIG_arg_fail(2)) SWIG_fail;
27146     }
27147     {
27148         PyThreadState* __tstate = wxPyBeginAllowThreads();
27149         result = (bool)(arg1)->base_Print(arg2);
27150
27151         wxPyEndAllowThreads(__tstate);
27152         if (PyErr_Occurred()) SWIG_fail;
27153     }
27154     {
27155         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27156     }
27157     return resultobj;
27158     fail:
27159     return NULL;
27160 }
27161
27162
27163 static PyObject *_wrap_PyPrintPreview_base_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
27164     PyObject *resultobj;
27165     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27166     PyObject * obj0 = 0 ;
27167     char *kwnames[] = {
27168         (char *) "self", NULL
27169     };
27170
27171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPrintPreview_base_DetermineScaling",kwnames,&obj0)) goto fail;
27172     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27173     if (SWIG_arg_fail(1)) SWIG_fail;
27174     {
27175         PyThreadState* __tstate = wxPyBeginAllowThreads();
27176         (arg1)->base_DetermineScaling();
27177
27178         wxPyEndAllowThreads(__tstate);
27179         if (PyErr_Occurred()) SWIG_fail;
27180     }
27181     Py_INCREF(Py_None); resultobj = Py_None;
27182     return resultobj;
27183     fail:
27184     return NULL;
27185 }
27186
27187
27188 static PyObject * PyPrintPreview_swigregister(PyObject *, PyObject *args) {
27189     PyObject *obj;
27190     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27191     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintPreview, obj);
27192     Py_INCREF(obj);
27193     return Py_BuildValue((char *)"");
27194 }
27195 static PyObject *_wrap_new_PyPreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
27196     PyObject *resultobj;
27197     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27198     wxFrame *arg2 = (wxFrame *) 0 ;
27199     wxString *arg3 = 0 ;
27200     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27201     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27202     wxSize const &arg5_defvalue = wxDefaultSize ;
27203     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27204     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
27205     wxString const &arg7_defvalue = wxPyFrameNameStr ;
27206     wxString *arg7 = (wxString *) &arg7_defvalue ;
27207     wxPyPreviewFrame *result;
27208     bool temp3 = false ;
27209     wxPoint temp4 ;
27210     wxSize temp5 ;
27211     bool temp7 = false ;
27212     PyObject * obj0 = 0 ;
27213     PyObject * obj1 = 0 ;
27214     PyObject * obj2 = 0 ;
27215     PyObject * obj3 = 0 ;
27216     PyObject * obj4 = 0 ;
27217     PyObject * obj5 = 0 ;
27218     PyObject * obj6 = 0 ;
27219     char *kwnames[] = {
27220         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27221     };
27222
27223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27225     if (SWIG_arg_fail(1)) SWIG_fail;
27226     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
27227     if (SWIG_arg_fail(2)) SWIG_fail;
27228     {
27229         arg3 = wxString_in_helper(obj2);
27230         if (arg3 == NULL) SWIG_fail;
27231         temp3 = true;
27232     }
27233     if (obj3) {
27234         {
27235             arg4 = &temp4;
27236             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27237         }
27238     }
27239     if (obj4) {
27240         {
27241             arg5 = &temp5;
27242             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27243         }
27244     }
27245     if (obj5) {
27246         {
27247             arg6 = (long)(SWIG_As_long(obj5));
27248             if (SWIG_arg_fail(6)) SWIG_fail;
27249         }
27250     }
27251     if (obj6) {
27252         {
27253             arg7 = wxString_in_helper(obj6);
27254             if (arg7 == NULL) SWIG_fail;
27255             temp7 = true;
27256         }
27257     }
27258     {
27259         if (!wxPyCheckForApp()) SWIG_fail;
27260         PyThreadState* __tstate = wxPyBeginAllowThreads();
27261         result = (wxPyPreviewFrame *)new wxPyPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27262
27263         wxPyEndAllowThreads(__tstate);
27264         if (PyErr_Occurred()) SWIG_fail;
27265     }
27266     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewFrame, 1);
27267     {
27268         if (temp3)
27269         delete arg3;
27270     }
27271     {
27272         if (temp7)
27273         delete arg7;
27274     }
27275     return resultobj;
27276     fail:
27277     {
27278         if (temp3)
27279         delete arg3;
27280     }
27281     {
27282         if (temp7)
27283         delete arg7;
27284     }
27285     return NULL;
27286 }
27287
27288
27289 static PyObject *_wrap_PyPreviewFrame__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27290     PyObject *resultobj;
27291     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27292     PyObject *arg2 = (PyObject *) 0 ;
27293     PyObject *arg3 = (PyObject *) 0 ;
27294     PyObject * obj0 = 0 ;
27295     PyObject * obj1 = 0 ;
27296     PyObject * obj2 = 0 ;
27297     char *kwnames[] = {
27298         (char *) "self",(char *) "self",(char *) "_class", NULL
27299     };
27300
27301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewFrame__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27303     if (SWIG_arg_fail(1)) SWIG_fail;
27304     arg2 = obj1;
27305     arg3 = obj2;
27306     {
27307         PyThreadState* __tstate = wxPyBeginAllowThreads();
27308         (arg1)->_setCallbackInfo(arg2,arg3);
27309
27310         wxPyEndAllowThreads(__tstate);
27311         if (PyErr_Occurred()) SWIG_fail;
27312     }
27313     Py_INCREF(Py_None); resultobj = Py_None;
27314     return resultobj;
27315     fail:
27316     return NULL;
27317 }
27318
27319
27320 static PyObject *_wrap_PyPreviewFrame_SetPreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27321     PyObject *resultobj;
27322     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27323     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27324     PyObject * obj0 = 0 ;
27325     PyObject * obj1 = 0 ;
27326     char *kwnames[] = {
27327         (char *) "self",(char *) "canvas", NULL
27328     };
27329
27330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetPreviewCanvas",kwnames,&obj0,&obj1)) goto fail;
27331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27332     if (SWIG_arg_fail(1)) SWIG_fail;
27333     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27334     if (SWIG_arg_fail(2)) SWIG_fail;
27335     {
27336         PyThreadState* __tstate = wxPyBeginAllowThreads();
27337         (arg1)->SetPreviewCanvas(arg2);
27338
27339         wxPyEndAllowThreads(__tstate);
27340         if (PyErr_Occurred()) SWIG_fail;
27341     }
27342     Py_INCREF(Py_None); resultobj = Py_None;
27343     return resultobj;
27344     fail:
27345     return NULL;
27346 }
27347
27348
27349 static PyObject *_wrap_PyPreviewFrame_SetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27350     PyObject *resultobj;
27351     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27352     wxPreviewControlBar *arg2 = (wxPreviewControlBar *) 0 ;
27353     PyObject * obj0 = 0 ;
27354     PyObject * obj1 = 0 ;
27355     char *kwnames[] = {
27356         (char *) "self",(char *) "bar", NULL
27357     };
27358
27359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetControlBar",kwnames,&obj0,&obj1)) goto fail;
27360     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27361     if (SWIG_arg_fail(1)) SWIG_fail;
27362     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27363     if (SWIG_arg_fail(2)) SWIG_fail;
27364     {
27365         PyThreadState* __tstate = wxPyBeginAllowThreads();
27366         (arg1)->SetControlBar(arg2);
27367
27368         wxPyEndAllowThreads(__tstate);
27369         if (PyErr_Occurred()) SWIG_fail;
27370     }
27371     Py_INCREF(Py_None); resultobj = Py_None;
27372     return resultobj;
27373     fail:
27374     return NULL;
27375 }
27376
27377
27378 static PyObject *_wrap_PyPreviewFrame_base_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
27379     PyObject *resultobj;
27380     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27381     PyObject * obj0 = 0 ;
27382     char *kwnames[] = {
27383         (char *) "self", NULL
27384     };
27385
27386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_Initialize",kwnames,&obj0)) goto fail;
27387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27388     if (SWIG_arg_fail(1)) SWIG_fail;
27389     {
27390         PyThreadState* __tstate = wxPyBeginAllowThreads();
27391         (arg1)->base_Initialize();
27392
27393         wxPyEndAllowThreads(__tstate);
27394         if (PyErr_Occurred()) SWIG_fail;
27395     }
27396     Py_INCREF(Py_None); resultobj = Py_None;
27397     return resultobj;
27398     fail:
27399     return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_PyPreviewFrame_base_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27404     PyObject *resultobj;
27405     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27406     PyObject * obj0 = 0 ;
27407     char *kwnames[] = {
27408         (char *) "self", NULL
27409     };
27410
27411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateCanvas",kwnames,&obj0)) goto fail;
27412     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27413     if (SWIG_arg_fail(1)) SWIG_fail;
27414     {
27415         PyThreadState* __tstate = wxPyBeginAllowThreads();
27416         (arg1)->base_CreateCanvas();
27417
27418         wxPyEndAllowThreads(__tstate);
27419         if (PyErr_Occurred()) SWIG_fail;
27420     }
27421     Py_INCREF(Py_None); resultobj = Py_None;
27422     return resultobj;
27423     fail:
27424     return NULL;
27425 }
27426
27427
27428 static PyObject *_wrap_PyPreviewFrame_base_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27429     PyObject *resultobj;
27430     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27431     PyObject * obj0 = 0 ;
27432     char *kwnames[] = {
27433         (char *) "self", NULL
27434     };
27435
27436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateControlBar",kwnames,&obj0)) goto fail;
27437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27438     if (SWIG_arg_fail(1)) SWIG_fail;
27439     {
27440         PyThreadState* __tstate = wxPyBeginAllowThreads();
27441         (arg1)->base_CreateControlBar();
27442
27443         wxPyEndAllowThreads(__tstate);
27444         if (PyErr_Occurred()) SWIG_fail;
27445     }
27446     Py_INCREF(Py_None); resultobj = Py_None;
27447     return resultobj;
27448     fail:
27449     return NULL;
27450 }
27451
27452
27453 static PyObject * PyPreviewFrame_swigregister(PyObject *, PyObject *args) {
27454     PyObject *obj;
27455     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27456     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewFrame, obj);
27457     Py_INCREF(obj);
27458     return Py_BuildValue((char *)"");
27459 }
27460 static PyObject *_wrap_new_PyPreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27461     PyObject *resultobj;
27462     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27463     long arg2 ;
27464     wxWindow *arg3 = (wxWindow *) 0 ;
27465     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27466     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27467     wxSize const &arg5_defvalue = wxDefaultSize ;
27468     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27469     long arg6 = (long) 0 ;
27470     wxString const &arg7_defvalue = wxPyPanelNameStr ;
27471     wxString *arg7 = (wxString *) &arg7_defvalue ;
27472     wxPyPreviewControlBar *result;
27473     wxPoint temp4 ;
27474     wxSize temp5 ;
27475     bool temp7 = false ;
27476     PyObject * obj0 = 0 ;
27477     PyObject * obj1 = 0 ;
27478     PyObject * obj2 = 0 ;
27479     PyObject * obj3 = 0 ;
27480     PyObject * obj4 = 0 ;
27481     PyObject * obj5 = 0 ;
27482     PyObject * obj6 = 0 ;
27483     char *kwnames[] = {
27484         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27485     };
27486
27487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27489     if (SWIG_arg_fail(1)) SWIG_fail;
27490     {
27491         arg2 = (long)(SWIG_As_long(obj1));
27492         if (SWIG_arg_fail(2)) SWIG_fail;
27493     }
27494     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27495     if (SWIG_arg_fail(3)) SWIG_fail;
27496     if (obj3) {
27497         {
27498             arg4 = &temp4;
27499             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27500         }
27501     }
27502     if (obj4) {
27503         {
27504             arg5 = &temp5;
27505             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27506         }
27507     }
27508     if (obj5) {
27509         {
27510             arg6 = (long)(SWIG_As_long(obj5));
27511             if (SWIG_arg_fail(6)) SWIG_fail;
27512         }
27513     }
27514     if (obj6) {
27515         {
27516             arg7 = wxString_in_helper(obj6);
27517             if (arg7 == NULL) SWIG_fail;
27518             temp7 = true;
27519         }
27520     }
27521     {
27522         if (!wxPyCheckForApp()) SWIG_fail;
27523         PyThreadState* __tstate = wxPyBeginAllowThreads();
27524         result = (wxPyPreviewControlBar *)new wxPyPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27525
27526         wxPyEndAllowThreads(__tstate);
27527         if (PyErr_Occurred()) SWIG_fail;
27528     }
27529     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewControlBar, 1);
27530     {
27531         if (temp7)
27532         delete arg7;
27533     }
27534     return resultobj;
27535     fail:
27536     {
27537         if (temp7)
27538         delete arg7;
27539     }
27540     return NULL;
27541 }
27542
27543
27544 static PyObject *_wrap_PyPreviewControlBar__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27545     PyObject *resultobj;
27546     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27547     PyObject *arg2 = (PyObject *) 0 ;
27548     PyObject *arg3 = (PyObject *) 0 ;
27549     PyObject * obj0 = 0 ;
27550     PyObject * obj1 = 0 ;
27551     PyObject * obj2 = 0 ;
27552     char *kwnames[] = {
27553         (char *) "self",(char *) "self",(char *) "_class", NULL
27554     };
27555
27556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewControlBar__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27558     if (SWIG_arg_fail(1)) SWIG_fail;
27559     arg2 = obj1;
27560     arg3 = obj2;
27561     {
27562         PyThreadState* __tstate = wxPyBeginAllowThreads();
27563         (arg1)->_setCallbackInfo(arg2,arg3);
27564
27565         wxPyEndAllowThreads(__tstate);
27566         if (PyErr_Occurred()) SWIG_fail;
27567     }
27568     Py_INCREF(Py_None); resultobj = Py_None;
27569     return resultobj;
27570     fail:
27571     return NULL;
27572 }
27573
27574
27575 static PyObject *_wrap_PyPreviewControlBar_SetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
27576     PyObject *resultobj;
27577     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27578     wxPrintPreview *arg2 = (wxPrintPreview *) 0 ;
27579     PyObject * obj0 = 0 ;
27580     PyObject * obj1 = 0 ;
27581     char *kwnames[] = {
27582         (char *) "self",(char *) "preview", NULL
27583     };
27584
27585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_SetPrintPreview",kwnames,&obj0,&obj1)) goto fail;
27586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27587     if (SWIG_arg_fail(1)) SWIG_fail;
27588     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27589     if (SWIG_arg_fail(2)) SWIG_fail;
27590     {
27591         PyThreadState* __tstate = wxPyBeginAllowThreads();
27592         (arg1)->SetPrintPreview(arg2);
27593
27594         wxPyEndAllowThreads(__tstate);
27595         if (PyErr_Occurred()) SWIG_fail;
27596     }
27597     Py_INCREF(Py_None); resultobj = Py_None;
27598     return resultobj;
27599     fail:
27600     return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_PyPreviewControlBar_base_CreateButtons(PyObject *, PyObject *args, PyObject *kwargs) {
27605     PyObject *resultobj;
27606     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27607     PyObject * obj0 = 0 ;
27608     char *kwnames[] = {
27609         (char *) "self", NULL
27610     };
27611
27612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewControlBar_base_CreateButtons",kwnames,&obj0)) goto fail;
27613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27614     if (SWIG_arg_fail(1)) SWIG_fail;
27615     {
27616         PyThreadState* __tstate = wxPyBeginAllowThreads();
27617         (arg1)->base_CreateButtons();
27618
27619         wxPyEndAllowThreads(__tstate);
27620         if (PyErr_Occurred()) SWIG_fail;
27621     }
27622     Py_INCREF(Py_None); resultobj = Py_None;
27623     return resultobj;
27624     fail:
27625     return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_PyPreviewControlBar_base_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
27630     PyObject *resultobj;
27631     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27632     int arg2 ;
27633     PyObject * obj0 = 0 ;
27634     PyObject * obj1 = 0 ;
27635     char *kwnames[] = {
27636         (char *) "self",(char *) "zoom", NULL
27637     };
27638
27639     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_base_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
27640     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27641     if (SWIG_arg_fail(1)) SWIG_fail;
27642     {
27643         arg2 = (int)(SWIG_As_int(obj1));
27644         if (SWIG_arg_fail(2)) SWIG_fail;
27645     }
27646     {
27647         PyThreadState* __tstate = wxPyBeginAllowThreads();
27648         (arg1)->base_SetZoomControl(arg2);
27649
27650         wxPyEndAllowThreads(__tstate);
27651         if (PyErr_Occurred()) SWIG_fail;
27652     }
27653     Py_INCREF(Py_None); resultobj = Py_None;
27654     return resultobj;
27655     fail:
27656     return NULL;
27657 }
27658
27659
27660 static PyObject * PyPreviewControlBar_swigregister(PyObject *, PyObject *args) {
27661     PyObject *obj;
27662     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27663     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewControlBar, obj);
27664     Py_INCREF(obj);
27665     return Py_BuildValue((char *)"");
27666 }
27667 static PyMethodDef SwigMethods[] = {
27668          { (char *)"new_Panel", (PyCFunction) _wrap_new_Panel, METH_VARARGS | METH_KEYWORDS, NULL},
27669          { (char *)"new_PrePanel", (PyCFunction) _wrap_new_PrePanel, METH_VARARGS | METH_KEYWORDS, NULL},
27670          { (char *)"Panel_Create", (PyCFunction) _wrap_Panel_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27671          { (char *)"Panel_InitDialog", (PyCFunction) _wrap_Panel_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27672          { (char *)"Panel_SetFocus", (PyCFunction) _wrap_Panel_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
27673          { (char *)"Panel_SetFocusIgnoringChildren", (PyCFunction) _wrap_Panel_SetFocusIgnoringChildren, METH_VARARGS | METH_KEYWORDS, NULL},
27674          { (char *)"Panel_GetClassDefaultAttributes", (PyCFunction) _wrap_Panel_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27675          { (char *)"Panel_swigregister", Panel_swigregister, METH_VARARGS, NULL},
27676          { (char *)"new_ScrolledWindow", (PyCFunction) _wrap_new_ScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27677          { (char *)"new_PreScrolledWindow", (PyCFunction) _wrap_new_PreScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27678          { (char *)"ScrolledWindow_Create", (PyCFunction) _wrap_ScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27679          { (char *)"ScrolledWindow_SetScrollbars", (PyCFunction) _wrap_ScrolledWindow_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27680          { (char *)"ScrolledWindow_Scroll", (PyCFunction) _wrap_ScrolledWindow_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},
27681          { (char *)"ScrolledWindow_GetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27682          { (char *)"ScrolledWindow_SetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27683          { (char *)"ScrolledWindow_SetScrollRate", (PyCFunction) _wrap_ScrolledWindow_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},
27684          { (char *)"ScrolledWindow_GetScrollPixelsPerUnit", (PyCFunction) _wrap_ScrolledWindow_GetScrollPixelsPerUnit, METH_VARARGS | METH_KEYWORDS, NULL},
27685          { (char *)"ScrolledWindow_EnableScrolling", (PyCFunction) _wrap_ScrolledWindow_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},
27686          { (char *)"ScrolledWindow_GetViewStart", (PyCFunction) _wrap_ScrolledWindow_GetViewStart, METH_VARARGS | METH_KEYWORDS, NULL},
27687          { (char *)"ScrolledWindow_SetScale", (PyCFunction) _wrap_ScrolledWindow_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},
27688          { (char *)"ScrolledWindow_GetScaleX", (PyCFunction) _wrap_ScrolledWindow_GetScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
27689          { (char *)"ScrolledWindow_GetScaleY", (PyCFunction) _wrap_ScrolledWindow_GetScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
27690          { (char *)"ScrolledWindow_CalcScrolledPosition", _wrap_ScrolledWindow_CalcScrolledPosition, METH_VARARGS, NULL},
27691          { (char *)"ScrolledWindow_CalcUnscrolledPosition", _wrap_ScrolledWindow_CalcUnscrolledPosition, METH_VARARGS, NULL},
27692          { (char *)"ScrolledWindow_AdjustScrollbars", (PyCFunction) _wrap_ScrolledWindow_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27693          { (char *)"ScrolledWindow_CalcScrollInc", (PyCFunction) _wrap_ScrolledWindow_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},
27694          { (char *)"ScrolledWindow_SetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27695          { (char *)"ScrolledWindow_GetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_GetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27696          { (char *)"ScrolledWindow_DoPrepareDC", (PyCFunction) _wrap_ScrolledWindow_DoPrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
27697          { (char *)"ScrolledWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrolledWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27698          { (char *)"ScrolledWindow_swigregister", ScrolledWindow_swigregister, METH_VARARGS, NULL},
27699          { (char *)"TopLevelWindow_Maximize", (PyCFunction) _wrap_TopLevelWindow_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
27700          { (char *)"TopLevelWindow_Restore", (PyCFunction) _wrap_TopLevelWindow_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
27701          { (char *)"TopLevelWindow_Iconize", (PyCFunction) _wrap_TopLevelWindow_Iconize, METH_VARARGS | METH_KEYWORDS, NULL},
27702          { (char *)"TopLevelWindow_IsMaximized", (PyCFunction) _wrap_TopLevelWindow_IsMaximized, METH_VARARGS | METH_KEYWORDS, NULL},
27703          { (char *)"TopLevelWindow_IsIconized", (PyCFunction) _wrap_TopLevelWindow_IsIconized, METH_VARARGS | METH_KEYWORDS, NULL},
27704          { (char *)"TopLevelWindow_GetIcon", (PyCFunction) _wrap_TopLevelWindow_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27705          { (char *)"TopLevelWindow_SetIcon", (PyCFunction) _wrap_TopLevelWindow_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27706          { (char *)"TopLevelWindow_SetIcons", (PyCFunction) _wrap_TopLevelWindow_SetIcons, METH_VARARGS | METH_KEYWORDS, NULL},
27707          { (char *)"TopLevelWindow_ShowFullScreen", (PyCFunction) _wrap_TopLevelWindow_ShowFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27708          { (char *)"TopLevelWindow_IsFullScreen", (PyCFunction) _wrap_TopLevelWindow_IsFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27709          { (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27710          { (char *)"TopLevelWindow_GetTitle", (PyCFunction) _wrap_TopLevelWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27711          { (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
27712          { (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
27713          { (char *)"TopLevelWindow_IsActive", (PyCFunction) _wrap_TopLevelWindow_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
27714          { (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27715          { (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacGetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27716          { (char *)"TopLevelWindow_swigregister", TopLevelWindow_swigregister, METH_VARARGS, NULL},
27717          { (char *)"new_Frame", (PyCFunction) _wrap_new_Frame, METH_VARARGS | METH_KEYWORDS, NULL},
27718          { (char *)"new_PreFrame", (PyCFunction) _wrap_new_PreFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27719          { (char *)"Frame_Create", (PyCFunction) _wrap_Frame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27720          { (char *)"Frame_GetClientAreaOrigin", (PyCFunction) _wrap_Frame_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
27721          { (char *)"Frame_SendSizeEvent", (PyCFunction) _wrap_Frame_SendSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27722          { (char *)"Frame_SetMenuBar", (PyCFunction) _wrap_Frame_SetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27723          { (char *)"Frame_GetMenuBar", (PyCFunction) _wrap_Frame_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27724          { (char *)"Frame_ProcessCommand", (PyCFunction) _wrap_Frame_ProcessCommand, METH_VARARGS | METH_KEYWORDS, NULL},
27725          { (char *)"Frame_CreateStatusBar", (PyCFunction) _wrap_Frame_CreateStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27726          { (char *)"Frame_GetStatusBar", (PyCFunction) _wrap_Frame_GetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27727          { (char *)"Frame_SetStatusBar", (PyCFunction) _wrap_Frame_SetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27728          { (char *)"Frame_SetStatusText", (PyCFunction) _wrap_Frame_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27729          { (char *)"Frame_SetStatusWidths", (PyCFunction) _wrap_Frame_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27730          { (char *)"Frame_PushStatusText", (PyCFunction) _wrap_Frame_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27731          { (char *)"Frame_PopStatusText", (PyCFunction) _wrap_Frame_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27732          { (char *)"Frame_SetStatusBarPane", (PyCFunction) _wrap_Frame_SetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27733          { (char *)"Frame_GetStatusBarPane", (PyCFunction) _wrap_Frame_GetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27734          { (char *)"Frame_CreateToolBar", (PyCFunction) _wrap_Frame_CreateToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27735          { (char *)"Frame_GetToolBar", (PyCFunction) _wrap_Frame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27736          { (char *)"Frame_SetToolBar", (PyCFunction) _wrap_Frame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27737          { (char *)"Frame_DoGiveHelp", (PyCFunction) _wrap_Frame_DoGiveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27738          { (char *)"Frame_DoMenuUpdates", (PyCFunction) _wrap_Frame_DoMenuUpdates, METH_VARARGS | METH_KEYWORDS, NULL},
27739          { (char *)"Frame_GetClassDefaultAttributes", (PyCFunction) _wrap_Frame_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27740          { (char *)"Frame_swigregister", Frame_swigregister, METH_VARARGS, NULL},
27741          { (char *)"new_Dialog", (PyCFunction) _wrap_new_Dialog, METH_VARARGS | METH_KEYWORDS, NULL},
27742          { (char *)"new_PreDialog", (PyCFunction) _wrap_new_PreDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27743          { (char *)"Dialog_Create", (PyCFunction) _wrap_Dialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27744          { (char *)"Dialog_SetReturnCode", (PyCFunction) _wrap_Dialog_SetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27745          { (char *)"Dialog_GetReturnCode", (PyCFunction) _wrap_Dialog_GetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27746          { (char *)"Dialog_CreateTextSizer", (PyCFunction) _wrap_Dialog_CreateTextSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27747          { (char *)"Dialog_CreateButtonSizer", (PyCFunction) _wrap_Dialog_CreateButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27748          { (char *)"Dialog_CreateStdDialogButtonSizer", (PyCFunction) _wrap_Dialog_CreateStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27749          { (char *)"Dialog_IsModal", (PyCFunction) _wrap_Dialog_IsModal, METH_VARARGS | METH_KEYWORDS, NULL},
27750          { (char *)"Dialog_ShowModal", (PyCFunction) _wrap_Dialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
27751          { (char *)"Dialog_EndModal", (PyCFunction) _wrap_Dialog_EndModal, METH_VARARGS | METH_KEYWORDS, NULL},
27752          { (char *)"Dialog_GetClassDefaultAttributes", (PyCFunction) _wrap_Dialog_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27753          { (char *)"Dialog_swigregister", Dialog_swigregister, METH_VARARGS, NULL},
27754          { (char *)"new_MiniFrame", (PyCFunction) _wrap_new_MiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27755          { (char *)"new_PreMiniFrame", (PyCFunction) _wrap_new_PreMiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27756          { (char *)"MiniFrame_Create", (PyCFunction) _wrap_MiniFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27757          { (char *)"MiniFrame_swigregister", MiniFrame_swigregister, METH_VARARGS, NULL},
27758          { (char *)"new_SplashScreenWindow", (PyCFunction) _wrap_new_SplashScreenWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27759          { (char *)"SplashScreenWindow_SetBitmap", (PyCFunction) _wrap_SplashScreenWindow_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27760          { (char *)"SplashScreenWindow_GetBitmap", (PyCFunction) _wrap_SplashScreenWindow_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27761          { (char *)"SplashScreenWindow_swigregister", SplashScreenWindow_swigregister, METH_VARARGS, NULL},
27762          { (char *)"new_SplashScreen", (PyCFunction) _wrap_new_SplashScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27763          { (char *)"SplashScreen_GetSplashStyle", (PyCFunction) _wrap_SplashScreen_GetSplashStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27764          { (char *)"SplashScreen_GetSplashWindow", (PyCFunction) _wrap_SplashScreen_GetSplashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27765          { (char *)"SplashScreen_GetTimeout", (PyCFunction) _wrap_SplashScreen_GetTimeout, METH_VARARGS | METH_KEYWORDS, NULL},
27766          { (char *)"SplashScreen_swigregister", SplashScreen_swigregister, METH_VARARGS, NULL},
27767          { (char *)"new_StatusBar", (PyCFunction) _wrap_new_StatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27768          { (char *)"new_PreStatusBar", (PyCFunction) _wrap_new_PreStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27769          { (char *)"StatusBar_Create", (PyCFunction) _wrap_StatusBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27770          { (char *)"StatusBar_SetFieldsCount", (PyCFunction) _wrap_StatusBar_SetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27771          { (char *)"StatusBar_GetFieldsCount", (PyCFunction) _wrap_StatusBar_GetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27772          { (char *)"StatusBar_SetStatusText", (PyCFunction) _wrap_StatusBar_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27773          { (char *)"StatusBar_GetStatusText", (PyCFunction) _wrap_StatusBar_GetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27774          { (char *)"StatusBar_PushStatusText", (PyCFunction) _wrap_StatusBar_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27775          { (char *)"StatusBar_PopStatusText", (PyCFunction) _wrap_StatusBar_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27776          { (char *)"StatusBar_SetStatusWidths", (PyCFunction) _wrap_StatusBar_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27777          { (char *)"StatusBar_SetStatusStyles", (PyCFunction) _wrap_StatusBar_SetStatusStyles, METH_VARARGS | METH_KEYWORDS, NULL},
27778          { (char *)"StatusBar_GetFieldRect", (PyCFunction) _wrap_StatusBar_GetFieldRect, METH_VARARGS | METH_KEYWORDS, NULL},
27779          { (char *)"StatusBar_SetMinHeight", (PyCFunction) _wrap_StatusBar_SetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
27780          { (char *)"StatusBar_GetBorderX", (PyCFunction) _wrap_StatusBar_GetBorderX, METH_VARARGS | METH_KEYWORDS, NULL},
27781          { (char *)"StatusBar_GetBorderY", (PyCFunction) _wrap_StatusBar_GetBorderY, METH_VARARGS | METH_KEYWORDS, NULL},
27782          { (char *)"StatusBar_GetClassDefaultAttributes", (PyCFunction) _wrap_StatusBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27783          { (char *)"StatusBar_swigregister", StatusBar_swigregister, METH_VARARGS, NULL},
27784          { (char *)"new_SplitterWindow", (PyCFunction) _wrap_new_SplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27785          { (char *)"new_PreSplitterWindow", (PyCFunction) _wrap_new_PreSplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27786          { (char *)"SplitterWindow_Create", (PyCFunction) _wrap_SplitterWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27787          { (char *)"SplitterWindow_GetWindow1", (PyCFunction) _wrap_SplitterWindow_GetWindow1, METH_VARARGS | METH_KEYWORDS, NULL},
27788          { (char *)"SplitterWindow_GetWindow2", (PyCFunction) _wrap_SplitterWindow_GetWindow2, METH_VARARGS | METH_KEYWORDS, NULL},
27789          { (char *)"SplitterWindow_SetSplitMode", (PyCFunction) _wrap_SplitterWindow_SetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27790          { (char *)"SplitterWindow_GetSplitMode", (PyCFunction) _wrap_SplitterWindow_GetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27791          { (char *)"SplitterWindow_Initialize", (PyCFunction) _wrap_SplitterWindow_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
27792          { (char *)"SplitterWindow_SplitVertically", (PyCFunction) _wrap_SplitterWindow_SplitVertically, METH_VARARGS | METH_KEYWORDS, NULL},
27793          { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL},
27794          { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL},
27795          { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27796          { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL},
27797          { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL},
27798          { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27799          { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27800          { (char *)"SplitterWindow_GetSashSize", (PyCFunction) _wrap_SplitterWindow_GetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27801          { (char *)"SplitterWindow_GetBorderSize", (PyCFunction) _wrap_SplitterWindow_GetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27802          { (char *)"SplitterWindow_SetSashPosition", (PyCFunction) _wrap_SplitterWindow_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27803          { (char *)"SplitterWindow_GetSashPosition", (PyCFunction) _wrap_SplitterWindow_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27804          { (char *)"SplitterWindow_SetSashGravity", (PyCFunction) _wrap_SplitterWindow_SetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27805          { (char *)"SplitterWindow_GetSashGravity", (PyCFunction) _wrap_SplitterWindow_GetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27806          { (char *)"SplitterWindow_SetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_SetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27807          { (char *)"SplitterWindow_GetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_GetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27808          { (char *)"SplitterWindow_SashHitTest", (PyCFunction) _wrap_SplitterWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27809          { (char *)"SplitterWindow_SizeWindows", (PyCFunction) _wrap_SplitterWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27810          { (char *)"SplitterWindow_SetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_SetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27811          { (char *)"SplitterWindow_GetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_GetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27812          { (char *)"SplitterWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_SplitterWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27813          { (char *)"SplitterWindow_swigregister", SplitterWindow_swigregister, METH_VARARGS, NULL},
27814          { (char *)"new_SplitterEvent", (PyCFunction) _wrap_new_SplitterEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27815          { (char *)"SplitterEvent_SetSashPosition", (PyCFunction) _wrap_SplitterEvent_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27816          { (char *)"SplitterEvent_GetSashPosition", (PyCFunction) _wrap_SplitterEvent_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27817          { (char *)"SplitterEvent_GetWindowBeingRemoved", (PyCFunction) _wrap_SplitterEvent_GetWindowBeingRemoved, METH_VARARGS | METH_KEYWORDS, NULL},
27818          { (char *)"SplitterEvent_GetX", (PyCFunction) _wrap_SplitterEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
27819          { (char *)"SplitterEvent_GetY", (PyCFunction) _wrap_SplitterEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
27820          { (char *)"SplitterEvent_swigregister", SplitterEvent_swigregister, METH_VARARGS, NULL},
27821          { (char *)"new_SashWindow", (PyCFunction) _wrap_new_SashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27822          { (char *)"new_PreSashWindow", (PyCFunction) _wrap_new_PreSashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27823          { (char *)"SashWindow_Create", (PyCFunction) _wrap_SashWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27824          { (char *)"SashWindow_SetSashVisible", (PyCFunction) _wrap_SashWindow_SetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27825          { (char *)"SashWindow_GetSashVisible", (PyCFunction) _wrap_SashWindow_GetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27826          { (char *)"SashWindow_SetSashBorder", (PyCFunction) _wrap_SashWindow_SetSashBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27827          { (char *)"SashWindow_HasBorder", (PyCFunction) _wrap_SashWindow_HasBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27828          { (char *)"SashWindow_GetEdgeMargin", (PyCFunction) _wrap_SashWindow_GetEdgeMargin, METH_VARARGS | METH_KEYWORDS, NULL},
27829          { (char *)"SashWindow_SetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_SetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27830          { (char *)"SashWindow_GetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_GetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27831          { (char *)"SashWindow_SetExtraBorderSize", (PyCFunction) _wrap_SashWindow_SetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27832          { (char *)"SashWindow_GetExtraBorderSize", (PyCFunction) _wrap_SashWindow_GetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27833          { (char *)"SashWindow_SetMinimumSizeX", (PyCFunction) _wrap_SashWindow_SetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27834          { (char *)"SashWindow_SetMinimumSizeY", (PyCFunction) _wrap_SashWindow_SetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27835          { (char *)"SashWindow_GetMinimumSizeX", (PyCFunction) _wrap_SashWindow_GetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27836          { (char *)"SashWindow_GetMinimumSizeY", (PyCFunction) _wrap_SashWindow_GetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27837          { (char *)"SashWindow_SetMaximumSizeX", (PyCFunction) _wrap_SashWindow_SetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27838          { (char *)"SashWindow_SetMaximumSizeY", (PyCFunction) _wrap_SashWindow_SetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27839          { (char *)"SashWindow_GetMaximumSizeX", (PyCFunction) _wrap_SashWindow_GetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27840          { (char *)"SashWindow_GetMaximumSizeY", (PyCFunction) _wrap_SashWindow_GetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27841          { (char *)"SashWindow_SashHitTest", (PyCFunction) _wrap_SashWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27842          { (char *)"SashWindow_SizeWindows", (PyCFunction) _wrap_SashWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27843          { (char *)"SashWindow_swigregister", SashWindow_swigregister, METH_VARARGS, NULL},
27844          { (char *)"new_SashEvent", (PyCFunction) _wrap_new_SashEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27845          { (char *)"SashEvent_SetEdge", (PyCFunction) _wrap_SashEvent_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27846          { (char *)"SashEvent_GetEdge", (PyCFunction) _wrap_SashEvent_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27847          { (char *)"SashEvent_SetDragRect", (PyCFunction) _wrap_SashEvent_SetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27848          { (char *)"SashEvent_GetDragRect", (PyCFunction) _wrap_SashEvent_GetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27849          { (char *)"SashEvent_SetDragStatus", (PyCFunction) _wrap_SashEvent_SetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27850          { (char *)"SashEvent_GetDragStatus", (PyCFunction) _wrap_SashEvent_GetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27851          { (char *)"SashEvent_swigregister", SashEvent_swigregister, METH_VARARGS, NULL},
27852          { (char *)"new_QueryLayoutInfoEvent", (PyCFunction) _wrap_new_QueryLayoutInfoEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27853          { (char *)"QueryLayoutInfoEvent_SetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27854          { (char *)"QueryLayoutInfoEvent_GetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27855          { (char *)"QueryLayoutInfoEvent_SetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27856          { (char *)"QueryLayoutInfoEvent_GetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27857          { (char *)"QueryLayoutInfoEvent_SetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27858          { (char *)"QueryLayoutInfoEvent_GetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27859          { (char *)"QueryLayoutInfoEvent_SetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27860          { (char *)"QueryLayoutInfoEvent_GetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27861          { (char *)"QueryLayoutInfoEvent_SetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27862          { (char *)"QueryLayoutInfoEvent_GetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27863          { (char *)"QueryLayoutInfoEvent_swigregister", QueryLayoutInfoEvent_swigregister, METH_VARARGS, NULL},
27864          { (char *)"new_CalculateLayoutEvent", (PyCFunction) _wrap_new_CalculateLayoutEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27865          { (char *)"CalculateLayoutEvent_SetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27866          { (char *)"CalculateLayoutEvent_GetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27867          { (char *)"CalculateLayoutEvent_SetRect", (PyCFunction) _wrap_CalculateLayoutEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27868          { (char *)"CalculateLayoutEvent_GetRect", (PyCFunction) _wrap_CalculateLayoutEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27869          { (char *)"CalculateLayoutEvent_swigregister", CalculateLayoutEvent_swigregister, METH_VARARGS, NULL},
27870          { (char *)"new_SashLayoutWindow", (PyCFunction) _wrap_new_SashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27871          { (char *)"new_PreSashLayoutWindow", (PyCFunction) _wrap_new_PreSashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27872          { (char *)"SashLayoutWindow_Create", (PyCFunction) _wrap_SashLayoutWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27873          { (char *)"SashLayoutWindow_GetAlignment", (PyCFunction) _wrap_SashLayoutWindow_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27874          { (char *)"SashLayoutWindow_GetOrientation", (PyCFunction) _wrap_SashLayoutWindow_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27875          { (char *)"SashLayoutWindow_SetAlignment", (PyCFunction) _wrap_SashLayoutWindow_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27876          { (char *)"SashLayoutWindow_SetDefaultSize", (PyCFunction) _wrap_SashLayoutWindow_SetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
27877          { (char *)"SashLayoutWindow_SetOrientation", (PyCFunction) _wrap_SashLayoutWindow_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27878          { (char *)"SashLayoutWindow_swigregister", SashLayoutWindow_swigregister, METH_VARARGS, NULL},
27879          { (char *)"new_LayoutAlgorithm", (PyCFunction) _wrap_new_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27880          { (char *)"delete_LayoutAlgorithm", (PyCFunction) _wrap_delete_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27881          { (char *)"LayoutAlgorithm_LayoutMDIFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutMDIFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27882          { (char *)"LayoutAlgorithm_LayoutFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27883          { (char *)"LayoutAlgorithm_LayoutWindow", (PyCFunction) _wrap_LayoutAlgorithm_LayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27884          { (char *)"LayoutAlgorithm_swigregister", LayoutAlgorithm_swigregister, METH_VARARGS, NULL},
27885          { (char *)"new_PopupWindow", (PyCFunction) _wrap_new_PopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27886          { (char *)"new_PrePopupWindow", (PyCFunction) _wrap_new_PrePopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27887          { (char *)"PopupWindow_Create", (PyCFunction) _wrap_PopupWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27888          { (char *)"PopupWindow_Position", (PyCFunction) _wrap_PopupWindow_Position, METH_VARARGS | METH_KEYWORDS, NULL},
27889          { (char *)"PopupWindow_swigregister", PopupWindow_swigregister, METH_VARARGS, NULL},
27890          { (char *)"new_PopupTransientWindow", (PyCFunction) _wrap_new_PopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27891          { (char *)"new_PrePopupTransientWindow", (PyCFunction) _wrap_new_PrePopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27892          { (char *)"PopupTransientWindow__setCallbackInfo", (PyCFunction) _wrap_PopupTransientWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27893          { (char *)"PopupTransientWindow_Popup", (PyCFunction) _wrap_PopupTransientWindow_Popup, METH_VARARGS | METH_KEYWORDS, NULL},
27894          { (char *)"PopupTransientWindow_Dismiss", (PyCFunction) _wrap_PopupTransientWindow_Dismiss, METH_VARARGS | METH_KEYWORDS, NULL},
27895          { (char *)"PopupTransientWindow_swigregister", PopupTransientWindow_swigregister, METH_VARARGS, NULL},
27896          { (char *)"new_TipWindow", (PyCFunction) _wrap_new_TipWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27897          { (char *)"TipWindow_SetBoundingRect", (PyCFunction) _wrap_TipWindow_SetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
27898          { (char *)"TipWindow_Close", (PyCFunction) _wrap_TipWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
27899          { (char *)"TipWindow_swigregister", TipWindow_swigregister, METH_VARARGS, NULL},
27900          { (char *)"new_VScrolledWindow", (PyCFunction) _wrap_new_VScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27901          { (char *)"new_PreVScrolledWindow", (PyCFunction) _wrap_new_PreVScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27902          { (char *)"VScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_VScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27903          { (char *)"VScrolledWindow_Create", (PyCFunction) _wrap_VScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27904          { (char *)"VScrolledWindow_SetLineCount", (PyCFunction) _wrap_VScrolledWindow_SetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27905          { (char *)"VScrolledWindow_ScrollToLine", (PyCFunction) _wrap_VScrolledWindow_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},
27906          { (char *)"VScrolledWindow_ScrollLines", (PyCFunction) _wrap_VScrolledWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
27907          { (char *)"VScrolledWindow_ScrollPages", (PyCFunction) _wrap_VScrolledWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
27908          { (char *)"VScrolledWindow_RefreshLine", (PyCFunction) _wrap_VScrolledWindow_RefreshLine, METH_VARARGS | METH_KEYWORDS, NULL},
27909          { (char *)"VScrolledWindow_RefreshLines", (PyCFunction) _wrap_VScrolledWindow_RefreshLines, METH_VARARGS | METH_KEYWORDS, NULL},
27910          { (char *)"VScrolledWindow_HitTestXY", (PyCFunction) _wrap_VScrolledWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
27911          { (char *)"VScrolledWindow_HitTest", (PyCFunction) _wrap_VScrolledWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27912          { (char *)"VScrolledWindow_RefreshAll", (PyCFunction) _wrap_VScrolledWindow_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27913          { (char *)"VScrolledWindow_GetLineCount", (PyCFunction) _wrap_VScrolledWindow_GetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27914          { (char *)"VScrolledWindow_GetFirstVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetFirstVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27915          { (char *)"VScrolledWindow_GetLastVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetLastVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27916          { (char *)"VScrolledWindow_IsVisible", (PyCFunction) _wrap_VScrolledWindow_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27917          { (char *)"VScrolledWindow_swigregister", VScrolledWindow_swigregister, METH_VARARGS, NULL},
27918          { (char *)"new_VListBox", (PyCFunction) _wrap_new_VListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27919          { (char *)"new_PreVListBox", (PyCFunction) _wrap_new_PreVListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27920          { (char *)"VListBox__setCallbackInfo", (PyCFunction) _wrap_VListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27921          { (char *)"VListBox_Create", (PyCFunction) _wrap_VListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27922          { (char *)"VListBox_GetItemCount", (PyCFunction) _wrap_VListBox_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27923          { (char *)"VListBox_HasMultipleSelection", (PyCFunction) _wrap_VListBox_HasMultipleSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27924          { (char *)"VListBox_GetSelection", (PyCFunction) _wrap_VListBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27925          { (char *)"VListBox_IsCurrent", (PyCFunction) _wrap_VListBox_IsCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
27926          { (char *)"VListBox_IsSelected", (PyCFunction) _wrap_VListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27927          { (char *)"VListBox_GetSelectedCount", (PyCFunction) _wrap_VListBox_GetSelectedCount, METH_VARARGS | METH_KEYWORDS, NULL},
27928          { (char *)"VListBox_GetFirstSelected", (PyCFunction) _wrap_VListBox_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27929          { (char *)"VListBox_GetNextSelected", (PyCFunction) _wrap_VListBox_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27930          { (char *)"VListBox_GetMargins", (PyCFunction) _wrap_VListBox_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27931          { (char *)"VListBox_GetSelectionBackground", (PyCFunction) _wrap_VListBox_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27932          { (char *)"VListBox_SetItemCount", (PyCFunction) _wrap_VListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27933          { (char *)"VListBox_Clear", (PyCFunction) _wrap_VListBox_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
27934          { (char *)"VListBox_SetSelection", (PyCFunction) _wrap_VListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27935          { (char *)"VListBox_Select", (PyCFunction) _wrap_VListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
27936          { (char *)"VListBox_SelectRange", (PyCFunction) _wrap_VListBox_SelectRange, METH_VARARGS | METH_KEYWORDS, NULL},
27937          { (char *)"VListBox_Toggle", (PyCFunction) _wrap_VListBox_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
27938          { (char *)"VListBox_SelectAll", (PyCFunction) _wrap_VListBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27939          { (char *)"VListBox_DeselectAll", (PyCFunction) _wrap_VListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27940          { (char *)"VListBox_SetMargins", (PyCFunction) _wrap_VListBox_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27941          { (char *)"VListBox_SetMarginsXY", (PyCFunction) _wrap_VListBox_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
27942          { (char *)"VListBox_SetSelectionBackground", (PyCFunction) _wrap_VListBox_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27943          { (char *)"VListBox_swigregister", VListBox_swigregister, METH_VARARGS, NULL},
27944          { (char *)"new_HtmlListBox", (PyCFunction) _wrap_new_HtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27945          { (char *)"new_PreHtmlListBox", (PyCFunction) _wrap_new_PreHtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27946          { (char *)"HtmlListBox__setCallbackInfo", (PyCFunction) _wrap_HtmlListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27947          { (char *)"HtmlListBox_Create", (PyCFunction) _wrap_HtmlListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27948          { (char *)"HtmlListBox_RefreshAll", (PyCFunction) _wrap_HtmlListBox_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27949          { (char *)"HtmlListBox_SetItemCount", (PyCFunction) _wrap_HtmlListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27950          { (char *)"HtmlListBox_GetFileSystem", (PyCFunction) _wrap_HtmlListBox_GetFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
27951          { (char *)"HtmlListBox_swigregister", HtmlListBox_swigregister, METH_VARARGS, NULL},
27952          { (char *)"new_TaskBarIcon", (PyCFunction) _wrap_new_TaskBarIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27953          { (char *)"TaskBarIcon__setCallbackInfo", (PyCFunction) _wrap_TaskBarIcon__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27954          { (char *)"TaskBarIcon_Destroy", (PyCFunction) _wrap_TaskBarIcon_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
27955          { (char *)"TaskBarIcon_IsOk", (PyCFunction) _wrap_TaskBarIcon_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
27956          { (char *)"TaskBarIcon_IsIconInstalled", (PyCFunction) _wrap_TaskBarIcon_IsIconInstalled, METH_VARARGS | METH_KEYWORDS, NULL},
27957          { (char *)"TaskBarIcon_SetIcon", (PyCFunction) _wrap_TaskBarIcon_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27958          { (char *)"TaskBarIcon_RemoveIcon", (PyCFunction) _wrap_TaskBarIcon_RemoveIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27959          { (char *)"TaskBarIcon_PopupMenu", (PyCFunction) _wrap_TaskBarIcon_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
27960          { (char *)"TaskBarIcon_swigregister", TaskBarIcon_swigregister, METH_VARARGS, NULL},
27961          { (char *)"new_TaskBarIconEvent", (PyCFunction) _wrap_new_TaskBarIconEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27962          { (char *)"TaskBarIconEvent_swigregister", TaskBarIconEvent_swigregister, METH_VARARGS, NULL},
27963          { (char *)"new_ColourData", (PyCFunction) _wrap_new_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27964          { (char *)"delete_ColourData", (PyCFunction) _wrap_delete_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27965          { (char *)"ColourData_GetChooseFull", (PyCFunction) _wrap_ColourData_GetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27966          { (char *)"ColourData_GetColour", (PyCFunction) _wrap_ColourData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27967          { (char *)"ColourData_GetCustomColour", (PyCFunction) _wrap_ColourData_GetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27968          { (char *)"ColourData_SetChooseFull", (PyCFunction) _wrap_ColourData_SetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27969          { (char *)"ColourData_SetColour", (PyCFunction) _wrap_ColourData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27970          { (char *)"ColourData_SetCustomColour", (PyCFunction) _wrap_ColourData_SetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27971          { (char *)"ColourData_swigregister", ColourData_swigregister, METH_VARARGS, NULL},
27972          { (char *)"new_ColourDialog", (PyCFunction) _wrap_new_ColourDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27973          { (char *)"ColourDialog_GetColourData", (PyCFunction) _wrap_ColourDialog_GetColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27974          { (char *)"ColourDialog_swigregister", ColourDialog_swigregister, METH_VARARGS, NULL},
27975          { (char *)"new_DirDialog", (PyCFunction) _wrap_new_DirDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27976          { (char *)"DirDialog_GetPath", (PyCFunction) _wrap_DirDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27977          { (char *)"DirDialog_GetMessage", (PyCFunction) _wrap_DirDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27978          { (char *)"DirDialog_GetStyle", (PyCFunction) _wrap_DirDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27979          { (char *)"DirDialog_SetMessage", (PyCFunction) _wrap_DirDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27980          { (char *)"DirDialog_SetPath", (PyCFunction) _wrap_DirDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27981          { (char *)"DirDialog_swigregister", DirDialog_swigregister, METH_VARARGS, NULL},
27982          { (char *)"new_FileDialog", (PyCFunction) _wrap_new_FileDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27983          { (char *)"FileDialog_SetMessage", (PyCFunction) _wrap_FileDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27984          { (char *)"FileDialog_SetPath", (PyCFunction) _wrap_FileDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27985          { (char *)"FileDialog_SetDirectory", (PyCFunction) _wrap_FileDialog_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27986          { (char *)"FileDialog_SetFilename", (PyCFunction) _wrap_FileDialog_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27987          { (char *)"FileDialog_SetWildcard", (PyCFunction) _wrap_FileDialog_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27988          { (char *)"FileDialog_SetStyle", (PyCFunction) _wrap_FileDialog_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27989          { (char *)"FileDialog_SetFilterIndex", (PyCFunction) _wrap_FileDialog_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27990          { (char *)"FileDialog_GetMessage", (PyCFunction) _wrap_FileDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27991          { (char *)"FileDialog_GetPath", (PyCFunction) _wrap_FileDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27992          { (char *)"FileDialog_GetDirectory", (PyCFunction) _wrap_FileDialog_GetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27993          { (char *)"FileDialog_GetFilename", (PyCFunction) _wrap_FileDialog_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27994          { (char *)"FileDialog_GetWildcard", (PyCFunction) _wrap_FileDialog_GetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27995          { (char *)"FileDialog_GetStyle", (PyCFunction) _wrap_FileDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27996          { (char *)"FileDialog_GetFilterIndex", (PyCFunction) _wrap_FileDialog_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27997          { (char *)"FileDialog_GetFilenames", (PyCFunction) _wrap_FileDialog_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
27998          { (char *)"FileDialog_GetPaths", (PyCFunction) _wrap_FileDialog_GetPaths, METH_VARARGS | METH_KEYWORDS, NULL},
27999          { (char *)"FileDialog_swigregister", FileDialog_swigregister, METH_VARARGS, NULL},
28000          { (char *)"new_MultiChoiceDialog", (PyCFunction) _wrap_new_MultiChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28001          { (char *)"MultiChoiceDialog_SetSelections", (PyCFunction) _wrap_MultiChoiceDialog_SetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28002          { (char *)"MultiChoiceDialog_GetSelections", (PyCFunction) _wrap_MultiChoiceDialog_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28003          { (char *)"MultiChoiceDialog_swigregister", MultiChoiceDialog_swigregister, METH_VARARGS, NULL},
28004          { (char *)"new_SingleChoiceDialog", (PyCFunction) _wrap_new_SingleChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28005          { (char *)"SingleChoiceDialog_GetSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28006          { (char *)"SingleChoiceDialog_GetStringSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28007          { (char *)"SingleChoiceDialog_SetSelection", (PyCFunction) _wrap_SingleChoiceDialog_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28008          { (char *)"SingleChoiceDialog_swigregister", SingleChoiceDialog_swigregister, METH_VARARGS, NULL},
28009          { (char *)"new_TextEntryDialog", (PyCFunction) _wrap_new_TextEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28010          { (char *)"TextEntryDialog_GetValue", (PyCFunction) _wrap_TextEntryDialog_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28011          { (char *)"TextEntryDialog_SetValue", (PyCFunction) _wrap_TextEntryDialog_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28012          { (char *)"TextEntryDialog_swigregister", TextEntryDialog_swigregister, METH_VARARGS, NULL},
28013          { (char *)"new_PasswordEntryDialog", (PyCFunction) _wrap_new_PasswordEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28014          { (char *)"PasswordEntryDialog_swigregister", PasswordEntryDialog_swigregister, METH_VARARGS, NULL},
28015          { (char *)"new_FontData", (PyCFunction) _wrap_new_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28016          { (char *)"delete_FontData", (PyCFunction) _wrap_delete_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28017          { (char *)"FontData_EnableEffects", (PyCFunction) _wrap_FontData_EnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28018          { (char *)"FontData_GetAllowSymbols", (PyCFunction) _wrap_FontData_GetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28019          { (char *)"FontData_GetColour", (PyCFunction) _wrap_FontData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28020          { (char *)"FontData_GetChosenFont", (PyCFunction) _wrap_FontData_GetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28021          { (char *)"FontData_GetEnableEffects", (PyCFunction) _wrap_FontData_GetEnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28022          { (char *)"FontData_GetInitialFont", (PyCFunction) _wrap_FontData_GetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28023          { (char *)"FontData_GetShowHelp", (PyCFunction) _wrap_FontData_GetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28024          { (char *)"FontData_SetAllowSymbols", (PyCFunction) _wrap_FontData_SetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28025          { (char *)"FontData_SetChosenFont", (PyCFunction) _wrap_FontData_SetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28026          { (char *)"FontData_SetColour", (PyCFunction) _wrap_FontData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28027          { (char *)"FontData_SetInitialFont", (PyCFunction) _wrap_FontData_SetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28028          { (char *)"FontData_SetRange", (PyCFunction) _wrap_FontData_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
28029          { (char *)"FontData_SetShowHelp", (PyCFunction) _wrap_FontData_SetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28030          { (char *)"FontData_swigregister", FontData_swigregister, METH_VARARGS, NULL},
28031          { (char *)"new_FontDialog", (PyCFunction) _wrap_new_FontDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28032          { (char *)"FontDialog_GetFontData", (PyCFunction) _wrap_FontDialog_GetFontData, METH_VARARGS | METH_KEYWORDS, NULL},
28033          { (char *)"FontDialog_swigregister", FontDialog_swigregister, METH_VARARGS, NULL},
28034          { (char *)"new_MessageDialog", (PyCFunction) _wrap_new_MessageDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28035          { (char *)"MessageDialog_swigregister", MessageDialog_swigregister, METH_VARARGS, NULL},
28036          { (char *)"new_ProgressDialog", (PyCFunction) _wrap_new_ProgressDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28037          { (char *)"ProgressDialog_Update", (PyCFunction) _wrap_ProgressDialog_Update, METH_VARARGS | METH_KEYWORDS, NULL},
28038          { (char *)"ProgressDialog_Resume", (PyCFunction) _wrap_ProgressDialog_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
28039          { (char *)"ProgressDialog_swigregister", ProgressDialog_swigregister, METH_VARARGS, NULL},
28040          { (char *)"new_FindDialogEvent", (PyCFunction) _wrap_new_FindDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28041          { (char *)"FindDialogEvent_GetFlags", (PyCFunction) _wrap_FindDialogEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28042          { (char *)"FindDialogEvent_GetFindString", (PyCFunction) _wrap_FindDialogEvent_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28043          { (char *)"FindDialogEvent_GetReplaceString", (PyCFunction) _wrap_FindDialogEvent_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28044          { (char *)"FindDialogEvent_GetDialog", (PyCFunction) _wrap_FindDialogEvent_GetDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28045          { (char *)"FindDialogEvent_SetFlags", (PyCFunction) _wrap_FindDialogEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28046          { (char *)"FindDialogEvent_SetFindString", (PyCFunction) _wrap_FindDialogEvent_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28047          { (char *)"FindDialogEvent_SetReplaceString", (PyCFunction) _wrap_FindDialogEvent_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28048          { (char *)"FindDialogEvent_swigregister", FindDialogEvent_swigregister, METH_VARARGS, NULL},
28049          { (char *)"new_FindReplaceData", (PyCFunction) _wrap_new_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28050          { (char *)"delete_FindReplaceData", (PyCFunction) _wrap_delete_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28051          { (char *)"FindReplaceData_GetFindString", (PyCFunction) _wrap_FindReplaceData_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28052          { (char *)"FindReplaceData_GetReplaceString", (PyCFunction) _wrap_FindReplaceData_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28053          { (char *)"FindReplaceData_GetFlags", (PyCFunction) _wrap_FindReplaceData_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28054          { (char *)"FindReplaceData_SetFlags", (PyCFunction) _wrap_FindReplaceData_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28055          { (char *)"FindReplaceData_SetFindString", (PyCFunction) _wrap_FindReplaceData_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28056          { (char *)"FindReplaceData_SetReplaceString", (PyCFunction) _wrap_FindReplaceData_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28057          { (char *)"FindReplaceData_swigregister", FindReplaceData_swigregister, METH_VARARGS, NULL},
28058          { (char *)"new_FindReplaceDialog", (PyCFunction) _wrap_new_FindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28059          { (char *)"new_PreFindReplaceDialog", (PyCFunction) _wrap_new_PreFindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28060          { (char *)"FindReplaceDialog_Create", (PyCFunction) _wrap_FindReplaceDialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28061          { (char *)"FindReplaceDialog_GetData", (PyCFunction) _wrap_FindReplaceDialog_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
28062          { (char *)"FindReplaceDialog_SetData", (PyCFunction) _wrap_FindReplaceDialog_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
28063          { (char *)"FindReplaceDialog_swigregister", FindReplaceDialog_swigregister, METH_VARARGS, NULL},
28064          { (char *)"new_MDIParentFrame", (PyCFunction) _wrap_new_MDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28065          { (char *)"new_PreMDIParentFrame", (PyCFunction) _wrap_new_PreMDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28066          { (char *)"MDIParentFrame_Create", (PyCFunction) _wrap_MDIParentFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28067          { (char *)"MDIParentFrame_ActivateNext", (PyCFunction) _wrap_MDIParentFrame_ActivateNext, METH_VARARGS | METH_KEYWORDS, NULL},
28068          { (char *)"MDIParentFrame_ActivatePrevious", (PyCFunction) _wrap_MDIParentFrame_ActivatePrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28069          { (char *)"MDIParentFrame_ArrangeIcons", (PyCFunction) _wrap_MDIParentFrame_ArrangeIcons, METH_VARARGS | METH_KEYWORDS, NULL},
28070          { (char *)"MDIParentFrame_Cascade", (PyCFunction) _wrap_MDIParentFrame_Cascade, METH_VARARGS | METH_KEYWORDS, NULL},
28071          { (char *)"MDIParentFrame_GetActiveChild", (PyCFunction) _wrap_MDIParentFrame_GetActiveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28072          { (char *)"MDIParentFrame_GetClientWindow", (PyCFunction) _wrap_MDIParentFrame_GetClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28073          { (char *)"MDIParentFrame_GetToolBar", (PyCFunction) _wrap_MDIParentFrame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28074          { (char *)"MDIParentFrame_Tile", (PyCFunction) _wrap_MDIParentFrame_Tile, METH_VARARGS | METH_KEYWORDS, NULL},
28075          { (char *)"MDIParentFrame_swigregister", MDIParentFrame_swigregister, METH_VARARGS, NULL},
28076          { (char *)"new_MDIChildFrame", (PyCFunction) _wrap_new_MDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28077          { (char *)"new_PreMDIChildFrame", (PyCFunction) _wrap_new_PreMDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28078          { (char *)"MDIChildFrame_Create", (PyCFunction) _wrap_MDIChildFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28079          { (char *)"MDIChildFrame_Activate", (PyCFunction) _wrap_MDIChildFrame_Activate, METH_VARARGS | METH_KEYWORDS, NULL},
28080          { (char *)"MDIChildFrame_Maximize", (PyCFunction) _wrap_MDIChildFrame_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
28081          { (char *)"MDIChildFrame_Restore", (PyCFunction) _wrap_MDIChildFrame_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
28082          { (char *)"MDIChildFrame_swigregister", MDIChildFrame_swigregister, METH_VARARGS, NULL},
28083          { (char *)"new_MDIClientWindow", (PyCFunction) _wrap_new_MDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28084          { (char *)"new_PreMDIClientWindow", (PyCFunction) _wrap_new_PreMDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28085          { (char *)"MDIClientWindow_Create", (PyCFunction) _wrap_MDIClientWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28086          { (char *)"MDIClientWindow_swigregister", MDIClientWindow_swigregister, METH_VARARGS, NULL},
28087          { (char *)"new_PyWindow", (PyCFunction) _wrap_new_PyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28088          { (char *)"new_PrePyWindow", (PyCFunction) _wrap_new_PrePyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28089          { (char *)"PyWindow__setCallbackInfo", (PyCFunction) _wrap_PyWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28090          { (char *)"PyWindow_SetBestSize", (PyCFunction) _wrap_PyWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28091          { (char *)"PyWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28092          { (char *)"PyWindow_base_DoSetSize", (PyCFunction) _wrap_PyWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28093          { (char *)"PyWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28094          { (char *)"PyWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28095          { (char *)"PyWindow_base_DoGetSize", (PyCFunction) _wrap_PyWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28096          { (char *)"PyWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28097          { (char *)"PyWindow_base_DoGetPosition", (PyCFunction) _wrap_PyWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28098          { (char *)"PyWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28099          { (char *)"PyWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28100          { (char *)"PyWindow_base_InitDialog", (PyCFunction) _wrap_PyWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28101          { (char *)"PyWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28102          { (char *)"PyWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28103          { (char *)"PyWindow_base_Validate", (PyCFunction) _wrap_PyWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28104          { (char *)"PyWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28105          { (char *)"PyWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28106          { (char *)"PyWindow_base_GetMaxSize", (PyCFunction) _wrap_PyWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28107          { (char *)"PyWindow_base_AddChild", (PyCFunction) _wrap_PyWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28108          { (char *)"PyWindow_base_RemoveChild", (PyCFunction) _wrap_PyWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28109          { (char *)"PyWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28110          { (char *)"PyWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28111          { (char *)"PyWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28112          { (char *)"PyWindow_swigregister", PyWindow_swigregister, METH_VARARGS, NULL},
28113          { (char *)"new_PyPanel", (PyCFunction) _wrap_new_PyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28114          { (char *)"new_PrePyPanel", (PyCFunction) _wrap_new_PrePyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28115          { (char *)"PyPanel__setCallbackInfo", (PyCFunction) _wrap_PyPanel__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28116          { (char *)"PyPanel_SetBestSize", (PyCFunction) _wrap_PyPanel_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28117          { (char *)"PyPanel_base_DoMoveWindow", (PyCFunction) _wrap_PyPanel_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28118          { (char *)"PyPanel_base_DoSetSize", (PyCFunction) _wrap_PyPanel_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28119          { (char *)"PyPanel_base_DoSetClientSize", (PyCFunction) _wrap_PyPanel_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28120          { (char *)"PyPanel_base_DoSetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28121          { (char *)"PyPanel_base_DoGetSize", (PyCFunction) _wrap_PyPanel_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28122          { (char *)"PyPanel_base_DoGetClientSize", (PyCFunction) _wrap_PyPanel_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28123          { (char *)"PyPanel_base_DoGetPosition", (PyCFunction) _wrap_PyPanel_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28124          { (char *)"PyPanel_base_DoGetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28125          { (char *)"PyPanel_base_DoGetBestSize", (PyCFunction) _wrap_PyPanel_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28126          { (char *)"PyPanel_base_InitDialog", (PyCFunction) _wrap_PyPanel_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28127          { (char *)"PyPanel_base_TransferDataToWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28128          { (char *)"PyPanel_base_TransferDataFromWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28129          { (char *)"PyPanel_base_Validate", (PyCFunction) _wrap_PyPanel_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28130          { (char *)"PyPanel_base_AcceptsFocus", (PyCFunction) _wrap_PyPanel_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28131          { (char *)"PyPanel_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyPanel_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28132          { (char *)"PyPanel_base_GetMaxSize", (PyCFunction) _wrap_PyPanel_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28133          { (char *)"PyPanel_base_AddChild", (PyCFunction) _wrap_PyPanel_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28134          { (char *)"PyPanel_base_RemoveChild", (PyCFunction) _wrap_PyPanel_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28135          { (char *)"PyPanel_base_ShouldInheritColours", (PyCFunction) _wrap_PyPanel_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28136          { (char *)"PyPanel_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyPanel_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28137          { (char *)"PyPanel_base_GetDefaultAttributes", (PyCFunction) _wrap_PyPanel_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28138          { (char *)"PyPanel_swigregister", PyPanel_swigregister, METH_VARARGS, NULL},
28139          { (char *)"new_PyScrolledWindow", (PyCFunction) _wrap_new_PyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28140          { (char *)"new_PrePyScrolledWindow", (PyCFunction) _wrap_new_PrePyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28141          { (char *)"PyScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_PyScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28142          { (char *)"PyScrolledWindow_SetBestSize", (PyCFunction) _wrap_PyScrolledWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28143          { (char *)"PyScrolledWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyScrolledWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28144          { (char *)"PyScrolledWindow_base_DoSetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28145          { (char *)"PyScrolledWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28146          { (char *)"PyScrolledWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28147          { (char *)"PyScrolledWindow_base_DoGetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28148          { (char *)"PyScrolledWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28149          { (char *)"PyScrolledWindow_base_DoGetPosition", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28150          { (char *)"PyScrolledWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28151          { (char *)"PyScrolledWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28152          { (char *)"PyScrolledWindow_base_InitDialog", (PyCFunction) _wrap_PyScrolledWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28153          { (char *)"PyScrolledWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28154          { (char *)"PyScrolledWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28155          { (char *)"PyScrolledWindow_base_Validate", (PyCFunction) _wrap_PyScrolledWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28156          { (char *)"PyScrolledWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28157          { (char *)"PyScrolledWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28158          { (char *)"PyScrolledWindow_base_GetMaxSize", (PyCFunction) _wrap_PyScrolledWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28159          { (char *)"PyScrolledWindow_base_AddChild", (PyCFunction) _wrap_PyScrolledWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28160          { (char *)"PyScrolledWindow_base_RemoveChild", (PyCFunction) _wrap_PyScrolledWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28161          { (char *)"PyScrolledWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyScrolledWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28162          { (char *)"PyScrolledWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyScrolledWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28163          { (char *)"PyScrolledWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyScrolledWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28164          { (char *)"PyScrolledWindow_swigregister", PyScrolledWindow_swigregister, METH_VARARGS, NULL},
28165          { (char *)"new_PrintData", _wrap_new_PrintData, METH_VARARGS, NULL},
28166          { (char *)"delete_PrintData", (PyCFunction) _wrap_delete_PrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28167          { (char *)"PrintData_GetNoCopies", (PyCFunction) _wrap_PrintData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28168          { (char *)"PrintData_GetCollate", (PyCFunction) _wrap_PrintData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28169          { (char *)"PrintData_GetOrientation", (PyCFunction) _wrap_PrintData_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28170          { (char *)"PrintData_Ok", (PyCFunction) _wrap_PrintData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28171          { (char *)"PrintData_GetPrinterName", (PyCFunction) _wrap_PrintData_GetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28172          { (char *)"PrintData_GetColour", (PyCFunction) _wrap_PrintData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28173          { (char *)"PrintData_GetDuplex", (PyCFunction) _wrap_PrintData_GetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28174          { (char *)"PrintData_GetPaperId", (PyCFunction) _wrap_PrintData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28175          { (char *)"PrintData_GetPaperSize", (PyCFunction) _wrap_PrintData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28176          { (char *)"PrintData_GetQuality", (PyCFunction) _wrap_PrintData_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28177          { (char *)"PrintData_GetBin", (PyCFunction) _wrap_PrintData_GetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28178          { (char *)"PrintData_GetPrintMode", (PyCFunction) _wrap_PrintData_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28179          { (char *)"PrintData_SetNoCopies", (PyCFunction) _wrap_PrintData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28180          { (char *)"PrintData_SetCollate", (PyCFunction) _wrap_PrintData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28181          { (char *)"PrintData_SetOrientation", (PyCFunction) _wrap_PrintData_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28182          { (char *)"PrintData_SetPrinterName", (PyCFunction) _wrap_PrintData_SetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28183          { (char *)"PrintData_SetColour", (PyCFunction) _wrap_PrintData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28184          { (char *)"PrintData_SetDuplex", (PyCFunction) _wrap_PrintData_SetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28185          { (char *)"PrintData_SetPaperId", (PyCFunction) _wrap_PrintData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28186          { (char *)"PrintData_SetPaperSize", (PyCFunction) _wrap_PrintData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28187          { (char *)"PrintData_SetQuality", (PyCFunction) _wrap_PrintData_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28188          { (char *)"PrintData_SetBin", (PyCFunction) _wrap_PrintData_SetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28189          { (char *)"PrintData_SetPrintMode", (PyCFunction) _wrap_PrintData_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28190          { (char *)"PrintData_GetFilename", (PyCFunction) _wrap_PrintData_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28191          { (char *)"PrintData_SetFilename", (PyCFunction) _wrap_PrintData_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28192          { (char *)"PrintData_GetPrivData", (PyCFunction) _wrap_PrintData_GetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28193          { (char *)"PrintData_SetPrivData", (PyCFunction) _wrap_PrintData_SetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28194          { (char *)"PrintData_GetPrinterCommand", (PyCFunction) _wrap_PrintData_GetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28195          { (char *)"PrintData_GetPrinterOptions", (PyCFunction) _wrap_PrintData_GetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28196          { (char *)"PrintData_GetPreviewCommand", (PyCFunction) _wrap_PrintData_GetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28197          { (char *)"PrintData_GetFontMetricPath", (PyCFunction) _wrap_PrintData_GetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28198          { (char *)"PrintData_GetPrinterScaleX", (PyCFunction) _wrap_PrintData_GetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28199          { (char *)"PrintData_GetPrinterScaleY", (PyCFunction) _wrap_PrintData_GetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28200          { (char *)"PrintData_GetPrinterTranslateX", (PyCFunction) _wrap_PrintData_GetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28201          { (char *)"PrintData_GetPrinterTranslateY", (PyCFunction) _wrap_PrintData_GetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28202          { (char *)"PrintData_SetPrinterCommand", (PyCFunction) _wrap_PrintData_SetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28203          { (char *)"PrintData_SetPrinterOptions", (PyCFunction) _wrap_PrintData_SetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28204          { (char *)"PrintData_SetPreviewCommand", (PyCFunction) _wrap_PrintData_SetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28205          { (char *)"PrintData_SetFontMetricPath", (PyCFunction) _wrap_PrintData_SetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28206          { (char *)"PrintData_SetPrinterScaleX", (PyCFunction) _wrap_PrintData_SetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28207          { (char *)"PrintData_SetPrinterScaleY", (PyCFunction) _wrap_PrintData_SetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28208          { (char *)"PrintData_SetPrinterScaling", (PyCFunction) _wrap_PrintData_SetPrinterScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28209          { (char *)"PrintData_SetPrinterTranslateX", (PyCFunction) _wrap_PrintData_SetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28210          { (char *)"PrintData_SetPrinterTranslateY", (PyCFunction) _wrap_PrintData_SetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28211          { (char *)"PrintData_SetPrinterTranslation", (PyCFunction) _wrap_PrintData_SetPrinterTranslation, METH_VARARGS | METH_KEYWORDS, NULL},
28212          { (char *)"PrintData_swigregister", PrintData_swigregister, METH_VARARGS, NULL},
28213          { (char *)"new_PageSetupDialogData", _wrap_new_PageSetupDialogData, METH_VARARGS, NULL},
28214          { (char *)"delete_PageSetupDialogData", (PyCFunction) _wrap_delete_PageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28215          { (char *)"PageSetupDialogData_EnableHelp", (PyCFunction) _wrap_PageSetupDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28216          { (char *)"PageSetupDialogData_EnableMargins", (PyCFunction) _wrap_PageSetupDialogData_EnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28217          { (char *)"PageSetupDialogData_EnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_EnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28218          { (char *)"PageSetupDialogData_EnablePaper", (PyCFunction) _wrap_PageSetupDialogData_EnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28219          { (char *)"PageSetupDialogData_EnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_EnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28220          { (char *)"PageSetupDialogData_GetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28221          { (char *)"PageSetupDialogData_GetEnableMargins", (PyCFunction) _wrap_PageSetupDialogData_GetEnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28222          { (char *)"PageSetupDialogData_GetEnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_GetEnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28223          { (char *)"PageSetupDialogData_GetEnablePaper", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28224          { (char *)"PageSetupDialogData_GetEnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28225          { (char *)"PageSetupDialogData_GetEnableHelp", (PyCFunction) _wrap_PageSetupDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28226          { (char *)"PageSetupDialogData_GetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28227          { (char *)"PageSetupDialogData_GetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28228          { (char *)"PageSetupDialogData_GetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28229          { (char *)"PageSetupDialogData_GetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28230          { (char *)"PageSetupDialogData_GetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28231          { (char *)"PageSetupDialogData_GetPaperId", (PyCFunction) _wrap_PageSetupDialogData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28232          { (char *)"PageSetupDialogData_GetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28233          { (char *)"PageSetupDialogData_GetPrintData", (PyCFunction) _wrap_PageSetupDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28234          { (char *)"PageSetupDialogData_Ok", (PyCFunction) _wrap_PageSetupDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28235          { (char *)"PageSetupDialogData_SetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28236          { (char *)"PageSetupDialogData_SetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28237          { (char *)"PageSetupDialogData_SetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28238          { (char *)"PageSetupDialogData_SetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28239          { (char *)"PageSetupDialogData_SetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28240          { (char *)"PageSetupDialogData_SetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28241          { (char *)"PageSetupDialogData_SetPaperId", (PyCFunction) _wrap_PageSetupDialogData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28242          { (char *)"PageSetupDialogData_SetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28243          { (char *)"PageSetupDialogData_SetPrintData", (PyCFunction) _wrap_PageSetupDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28244          { (char *)"PageSetupDialogData_CalculateIdFromPaperSize", (PyCFunction) _wrap_PageSetupDialogData_CalculateIdFromPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28245          { (char *)"PageSetupDialogData_CalculatePaperSizeFromId", (PyCFunction) _wrap_PageSetupDialogData_CalculatePaperSizeFromId, METH_VARARGS | METH_KEYWORDS, NULL},
28246          { (char *)"PageSetupDialogData_swigregister", PageSetupDialogData_swigregister, METH_VARARGS, NULL},
28247          { (char *)"new_PageSetupDialog", (PyCFunction) _wrap_new_PageSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28248          { (char *)"PageSetupDialog_GetPageSetupData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},
28249          { (char *)"PageSetupDialog_GetPageSetupDialogData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28250          { (char *)"PageSetupDialog_ShowModal", (PyCFunction) _wrap_PageSetupDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28251          { (char *)"PageSetupDialog_swigregister", PageSetupDialog_swigregister, METH_VARARGS, NULL},
28252          { (char *)"new_PrintDialogData", _wrap_new_PrintDialogData, METH_VARARGS, NULL},
28253          { (char *)"delete_PrintDialogData", (PyCFunction) _wrap_delete_PrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28254          { (char *)"PrintDialogData_GetFromPage", (PyCFunction) _wrap_PrintDialogData_GetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28255          { (char *)"PrintDialogData_GetToPage", (PyCFunction) _wrap_PrintDialogData_GetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28256          { (char *)"PrintDialogData_GetMinPage", (PyCFunction) _wrap_PrintDialogData_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28257          { (char *)"PrintDialogData_GetMaxPage", (PyCFunction) _wrap_PrintDialogData_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28258          { (char *)"PrintDialogData_GetNoCopies", (PyCFunction) _wrap_PrintDialogData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28259          { (char *)"PrintDialogData_GetAllPages", (PyCFunction) _wrap_PrintDialogData_GetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28260          { (char *)"PrintDialogData_GetSelection", (PyCFunction) _wrap_PrintDialogData_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28261          { (char *)"PrintDialogData_GetCollate", (PyCFunction) _wrap_PrintDialogData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28262          { (char *)"PrintDialogData_GetPrintToFile", (PyCFunction) _wrap_PrintDialogData_GetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28263          { (char *)"PrintDialogData_GetSetupDialog", (PyCFunction) _wrap_PrintDialogData_GetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28264          { (char *)"PrintDialogData_SetSetupDialog", (PyCFunction) _wrap_PrintDialogData_SetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28265          { (char *)"PrintDialogData_SetFromPage", (PyCFunction) _wrap_PrintDialogData_SetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28266          { (char *)"PrintDialogData_SetToPage", (PyCFunction) _wrap_PrintDialogData_SetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28267          { (char *)"PrintDialogData_SetMinPage", (PyCFunction) _wrap_PrintDialogData_SetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28268          { (char *)"PrintDialogData_SetMaxPage", (PyCFunction) _wrap_PrintDialogData_SetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28269          { (char *)"PrintDialogData_SetNoCopies", (PyCFunction) _wrap_PrintDialogData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28270          { (char *)"PrintDialogData_SetAllPages", (PyCFunction) _wrap_PrintDialogData_SetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28271          { (char *)"PrintDialogData_SetSelection", (PyCFunction) _wrap_PrintDialogData_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28272          { (char *)"PrintDialogData_SetCollate", (PyCFunction) _wrap_PrintDialogData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28273          { (char *)"PrintDialogData_SetPrintToFile", (PyCFunction) _wrap_PrintDialogData_SetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28274          { (char *)"PrintDialogData_EnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_EnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28275          { (char *)"PrintDialogData_EnableSelection", (PyCFunction) _wrap_PrintDialogData_EnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28276          { (char *)"PrintDialogData_EnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_EnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28277          { (char *)"PrintDialogData_EnableHelp", (PyCFunction) _wrap_PrintDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28278          { (char *)"PrintDialogData_GetEnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_GetEnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28279          { (char *)"PrintDialogData_GetEnableSelection", (PyCFunction) _wrap_PrintDialogData_GetEnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28280          { (char *)"PrintDialogData_GetEnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_GetEnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28281          { (char *)"PrintDialogData_GetEnableHelp", (PyCFunction) _wrap_PrintDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28282          { (char *)"PrintDialogData_Ok", (PyCFunction) _wrap_PrintDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28283          { (char *)"PrintDialogData_GetPrintData", (PyCFunction) _wrap_PrintDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28284          { (char *)"PrintDialogData_SetPrintData", (PyCFunction) _wrap_PrintDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28285          { (char *)"PrintDialogData_swigregister", PrintDialogData_swigregister, METH_VARARGS, NULL},
28286          { (char *)"new_PrintDialog", (PyCFunction) _wrap_new_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28287          { (char *)"PrintDialog_ShowModal", (PyCFunction) _wrap_PrintDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28288          { (char *)"PrintDialog_GetPrintDialogData", (PyCFunction) _wrap_PrintDialog_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28289          { (char *)"PrintDialog_GetPrintData", (PyCFunction) _wrap_PrintDialog_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28290          { (char *)"PrintDialog_GetPrintDC", (PyCFunction) _wrap_PrintDialog_GetPrintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28291          { (char *)"PrintDialog_swigregister", PrintDialog_swigregister, METH_VARARGS, NULL},
28292          { (char *)"new_Printer", (PyCFunction) _wrap_new_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28293          { (char *)"delete_Printer", (PyCFunction) _wrap_delete_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28294          { (char *)"Printer_CreateAbortWindow", (PyCFunction) _wrap_Printer_CreateAbortWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28295          { (char *)"Printer_ReportError", (PyCFunction) _wrap_Printer_ReportError, METH_VARARGS | METH_KEYWORDS, NULL},
28296          { (char *)"Printer_Setup", (PyCFunction) _wrap_Printer_Setup, METH_VARARGS | METH_KEYWORDS, NULL},
28297          { (char *)"Printer_Print", (PyCFunction) _wrap_Printer_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28298          { (char *)"Printer_PrintDialog", (PyCFunction) _wrap_Printer_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28299          { (char *)"Printer_GetPrintDialogData", (PyCFunction) _wrap_Printer_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28300          { (char *)"Printer_GetAbort", (PyCFunction) _wrap_Printer_GetAbort, METH_VARARGS | METH_KEYWORDS, NULL},
28301          { (char *)"Printer_GetLastError", (PyCFunction) _wrap_Printer_GetLastError, METH_VARARGS | METH_KEYWORDS, NULL},
28302          { (char *)"Printer_swigregister", Printer_swigregister, METH_VARARGS, NULL},
28303          { (char *)"new_Printout", (PyCFunction) _wrap_new_Printout, METH_VARARGS | METH_KEYWORDS, NULL},
28304          { (char *)"Printout__setCallbackInfo", (PyCFunction) _wrap_Printout__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28305          { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28306          { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28307          { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28308          { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28309          { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28310          { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28311          { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28312          { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28313          { (char *)"Printout_GetPPIScreen", (PyCFunction) _wrap_Printout_GetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28314          { (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28315          { (char *)"Printout_GetPPIPrinter", (PyCFunction) _wrap_Printout_GetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28316          { (char *)"Printout_IsPreview", (PyCFunction) _wrap_Printout_IsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28317          { (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28318          { (char *)"Printout_base_OnBeginDocument", (PyCFunction) _wrap_Printout_base_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28319          { (char *)"Printout_base_OnEndDocument", (PyCFunction) _wrap_Printout_base_OnEndDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28320          { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28321          { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28322          { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28323          { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS, NULL},
28324          { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28325          { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS, NULL},
28326          { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28327          { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS, NULL},
28328          { (char *)"new_PreviewFrame", (PyCFunction) _wrap_new_PreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28329          { (char *)"PreviewFrame_Initialize", (PyCFunction) _wrap_PreviewFrame_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28330          { (char *)"PreviewFrame_CreateControlBar", (PyCFunction) _wrap_PreviewFrame_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28331          { (char *)"PreviewFrame_CreateCanvas", (PyCFunction) _wrap_PreviewFrame_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28332          { (char *)"PreviewFrame_GetControlBar", (PyCFunction) _wrap_PreviewFrame_GetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28333          { (char *)"PreviewFrame_swigregister", PreviewFrame_swigregister, METH_VARARGS, NULL},
28334          { (char *)"new_PreviewControlBar", (PyCFunction) _wrap_new_PreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28335          { (char *)"PreviewControlBar_GetZoomControl", (PyCFunction) _wrap_PreviewControlBar_GetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28336          { (char *)"PreviewControlBar_SetZoomControl", (PyCFunction) _wrap_PreviewControlBar_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28337          { (char *)"PreviewControlBar_GetPrintPreview", (PyCFunction) _wrap_PreviewControlBar_GetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28338          { (char *)"PreviewControlBar_OnNext", (PyCFunction) _wrap_PreviewControlBar_OnNext, METH_VARARGS | METH_KEYWORDS, NULL},
28339          { (char *)"PreviewControlBar_OnPrevious", (PyCFunction) _wrap_PreviewControlBar_OnPrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28340          { (char *)"PreviewControlBar_OnFirst", (PyCFunction) _wrap_PreviewControlBar_OnFirst, METH_VARARGS | METH_KEYWORDS, NULL},
28341          { (char *)"PreviewControlBar_OnLast", (PyCFunction) _wrap_PreviewControlBar_OnLast, METH_VARARGS | METH_KEYWORDS, NULL},
28342          { (char *)"PreviewControlBar_OnGoto", (PyCFunction) _wrap_PreviewControlBar_OnGoto, METH_VARARGS | METH_KEYWORDS, NULL},
28343          { (char *)"PreviewControlBar_swigregister", PreviewControlBar_swigregister, METH_VARARGS, NULL},
28344          { (char *)"new_PrintPreview", _wrap_new_PrintPreview, METH_VARARGS, NULL},
28345          { (char *)"PrintPreview_SetCurrentPage", (PyCFunction) _wrap_PrintPreview_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28346          { (char *)"PrintPreview_GetCurrentPage", (PyCFunction) _wrap_PrintPreview_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28347          { (char *)"PrintPreview_SetPrintout", (PyCFunction) _wrap_PrintPreview_SetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28348          { (char *)"PrintPreview_GetPrintout", (PyCFunction) _wrap_PrintPreview_GetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28349          { (char *)"PrintPreview_GetPrintoutForPrinting", (PyCFunction) _wrap_PrintPreview_GetPrintoutForPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28350          { (char *)"PrintPreview_SetFrame", (PyCFunction) _wrap_PrintPreview_SetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28351          { (char *)"PrintPreview_SetCanvas", (PyCFunction) _wrap_PrintPreview_SetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28352          { (char *)"PrintPreview_GetFrame", (PyCFunction) _wrap_PrintPreview_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28353          { (char *)"PrintPreview_GetCanvas", (PyCFunction) _wrap_PrintPreview_GetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28354          { (char *)"PrintPreview_PaintPage", (PyCFunction) _wrap_PrintPreview_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28355          { (char *)"PrintPreview_DrawBlankPage", (PyCFunction) _wrap_PrintPreview_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28356          { (char *)"PrintPreview_RenderPage", (PyCFunction) _wrap_PrintPreview_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28357          { (char *)"PrintPreview_AdjustScrollbars", (PyCFunction) _wrap_PrintPreview_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
28358          { (char *)"PrintPreview_GetPrintDialogData", (PyCFunction) _wrap_PrintPreview_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28359          { (char *)"PrintPreview_SetZoom", (PyCFunction) _wrap_PrintPreview_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28360          { (char *)"PrintPreview_GetZoom", (PyCFunction) _wrap_PrintPreview_GetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28361          { (char *)"PrintPreview_GetMaxPage", (PyCFunction) _wrap_PrintPreview_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28362          { (char *)"PrintPreview_GetMinPage", (PyCFunction) _wrap_PrintPreview_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28363          { (char *)"PrintPreview_Ok", (PyCFunction) _wrap_PrintPreview_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28364          { (char *)"PrintPreview_SetOk", (PyCFunction) _wrap_PrintPreview_SetOk, METH_VARARGS | METH_KEYWORDS, NULL},
28365          { (char *)"PrintPreview_Print", (PyCFunction) _wrap_PrintPreview_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28366          { (char *)"PrintPreview_DetermineScaling", (PyCFunction) _wrap_PrintPreview_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28367          { (char *)"PrintPreview_swigregister", PrintPreview_swigregister, METH_VARARGS, NULL},
28368          { (char *)"new_PyPrintPreview", _wrap_new_PyPrintPreview, METH_VARARGS, NULL},
28369          { (char *)"PyPrintPreview__setCallbackInfo", (PyCFunction) _wrap_PyPrintPreview__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28370          { (char *)"PyPrintPreview_base_SetCurrentPage", (PyCFunction) _wrap_PyPrintPreview_base_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28371          { (char *)"PyPrintPreview_base_PaintPage", (PyCFunction) _wrap_PyPrintPreview_base_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28372          { (char *)"PyPrintPreview_base_DrawBlankPage", (PyCFunction) _wrap_PyPrintPreview_base_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28373          { (char *)"PyPrintPreview_base_RenderPage", (PyCFunction) _wrap_PyPrintPreview_base_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28374          { (char *)"PyPrintPreview_base_SetZoom", (PyCFunction) _wrap_PyPrintPreview_base_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28375          { (char *)"PyPrintPreview_base_Print", (PyCFunction) _wrap_PyPrintPreview_base_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28376          { (char *)"PyPrintPreview_base_DetermineScaling", (PyCFunction) _wrap_PyPrintPreview_base_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28377          { (char *)"PyPrintPreview_swigregister", PyPrintPreview_swigregister, METH_VARARGS, NULL},
28378          { (char *)"new_PyPreviewFrame", (PyCFunction) _wrap_new_PyPreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28379          { (char *)"PyPreviewFrame__setCallbackInfo", (PyCFunction) _wrap_PyPreviewFrame__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28380          { (char *)"PyPreviewFrame_SetPreviewCanvas", (PyCFunction) _wrap_PyPreviewFrame_SetPreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28381          { (char *)"PyPreviewFrame_SetControlBar", (PyCFunction) _wrap_PyPreviewFrame_SetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28382          { (char *)"PyPreviewFrame_base_Initialize", (PyCFunction) _wrap_PyPreviewFrame_base_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28383          { (char *)"PyPreviewFrame_base_CreateCanvas", (PyCFunction) _wrap_PyPreviewFrame_base_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28384          { (char *)"PyPreviewFrame_base_CreateControlBar", (PyCFunction) _wrap_PyPreviewFrame_base_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28385          { (char *)"PyPreviewFrame_swigregister", PyPreviewFrame_swigregister, METH_VARARGS, NULL},
28386          { (char *)"new_PyPreviewControlBar", (PyCFunction) _wrap_new_PyPreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28387          { (char *)"PyPreviewControlBar__setCallbackInfo", (PyCFunction) _wrap_PyPreviewControlBar__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28388          { (char *)"PyPreviewControlBar_SetPrintPreview", (PyCFunction) _wrap_PyPreviewControlBar_SetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28389          { (char *)"PyPreviewControlBar_base_CreateButtons", (PyCFunction) _wrap_PyPreviewControlBar_base_CreateButtons, METH_VARARGS | METH_KEYWORDS, NULL},
28390          { (char *)"PyPreviewControlBar_base_SetZoomControl", (PyCFunction) _wrap_PyPreviewControlBar_base_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28391          { (char *)"PyPreviewControlBar_swigregister", PyPreviewControlBar_swigregister, METH_VARARGS, NULL},
28392          { NULL, NULL, 0, NULL }
28393 };
28394
28395
28396 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28397
28398 static void *_p_wxPyPreviewFrameTo_p_wxPreviewFrame(void *x) {
28399     return (void *)((wxPreviewFrame *)  ((wxPyPreviewFrame *) x));
28400 }
28401 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
28402     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
28403 }
28404 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
28405     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
28406 }
28407 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
28408     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
28409 }
28410 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
28411     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
28412 }
28413 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
28414     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
28415 }
28416 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
28417     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
28418 }
28419 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
28420     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28421 }
28422 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
28423     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
28424 }
28425 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
28426     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
28427 }
28428 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
28429     return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
28430 }
28431 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
28432     return (void *)((wxEvent *)  ((wxPyEvent *) x));
28433 }
28434 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
28435     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
28436 }
28437 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
28438     return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
28439 }
28440 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
28441     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
28442 }
28443 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
28444     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
28445 }
28446 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
28447     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
28448 }
28449 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
28450     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
28451 }
28452 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
28453     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
28454 }
28455 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
28456     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
28457 }
28458 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
28459     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
28460 }
28461 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
28462     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
28463 }
28464 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
28465     return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
28466 }
28467 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
28468     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
28469 }
28470 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
28471     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
28472 }
28473 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
28474     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
28475 }
28476 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
28477     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
28478 }
28479 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
28480     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
28481 }
28482 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
28483     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
28484 }
28485 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
28486     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
28487 }
28488 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
28489     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
28490 }
28491 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
28492     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
28493 }
28494 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
28495     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
28496 }
28497 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
28498     return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
28499 }
28500 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
28501     return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
28502 }
28503 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
28504     return (void *)((wxEvent *)  ((wxShowEvent *) x));
28505 }
28506 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
28507     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
28508 }
28509 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
28510     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
28511 }
28512 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
28513     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28514 }
28515 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
28516     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
28517 }
28518 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
28519     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
28520 }
28521 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
28522     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
28523 }
28524 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
28525     return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
28526 }
28527 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
28528     return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
28529 }
28530 static void *_p_wxPasswordEntryDialogTo_p_wxTextEntryDialog(void *x) {
28531     return (void *)((wxTextEntryDialog *)  ((wxPasswordEntryDialog *) x));
28532 }
28533 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
28534     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28535 }
28536 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
28537     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28538 }
28539 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
28540     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28541 }
28542 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
28543     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
28544 }
28545 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
28546     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
28547 }
28548 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
28549     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
28550 }
28551 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
28552     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
28553 }
28554 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
28555     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28556 }
28557 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
28558     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28559 }
28560 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
28561     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28562 }
28563 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
28564     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28565 }
28566 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
28567     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28568 }
28569 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
28570     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28571 }
28572 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
28573     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28574 }
28575 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
28576     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28577 }
28578 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
28579     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
28580 }
28581 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
28582     return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
28583 }
28584 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
28585     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28586 }
28587 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
28588     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
28589 }
28590 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
28591     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28592 }
28593 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
28594     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
28595 }
28596 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
28597     return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28598 }
28599 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
28600     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
28601 }
28602 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
28603     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
28604 }
28605 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
28606     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
28607 }
28608 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
28609     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
28610 }
28611 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
28612     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28613 }
28614 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
28615     return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
28616 }
28617 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
28618     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
28619 }
28620 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
28621     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28622 }
28623 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
28624     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
28625 }
28626 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
28627     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28628 }
28629 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
28630     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28631 }
28632 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
28633     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28634 }
28635 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
28636     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
28637 }
28638 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
28639     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
28640 }
28641 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
28642     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
28643 }
28644 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
28645     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28646 }
28647 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
28648     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28649 }
28650 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
28651     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28652 }
28653 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
28654     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
28655 }
28656 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
28657     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
28658 }
28659 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
28660     return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
28661 }
28662 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
28663     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28664 }
28665 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
28666     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
28667 }
28668 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
28669     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
28670 }
28671 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
28672     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
28673 }
28674 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
28675     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
28676 }
28677 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
28678     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28679 }
28680 static void *_p_wxPyHtmlListBoxTo_p_wxPyVListBox(void *x) {
28681     return (void *)((wxPyVListBox *)  ((wxPyHtmlListBox *) x));
28682 }
28683 static void *_p_wxMDIChildFrameTo_p_wxFrame(void *x) {
28684     return (void *)((wxFrame *)  ((wxMDIChildFrame *) x));
28685 }
28686 static void *_p_wxProgressDialogTo_p_wxFrame(void *x) {
28687     return (void *)((wxFrame *)  ((wxProgressDialog *) x));
28688 }
28689 static void *_p_wxPreviewFrameTo_p_wxFrame(void *x) {
28690     return (void *)((wxFrame *)  ((wxPreviewFrame *) x));
28691 }
28692 static void *_p_wxPyPreviewFrameTo_p_wxFrame(void *x) {
28693     return (void *)((wxFrame *) (wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28694 }
28695 static void *_p_wxMiniFrameTo_p_wxFrame(void *x) {
28696     return (void *)((wxFrame *)  ((wxMiniFrame *) x));
28697 }
28698 static void *_p_wxSplashScreenTo_p_wxFrame(void *x) {
28699     return (void *)((wxFrame *)  ((wxSplashScreen *) x));
28700 }
28701 static void *_p_wxMDIParentFrameTo_p_wxFrame(void *x) {
28702     return (void *)((wxFrame *)  ((wxMDIParentFrame *) x));
28703 }
28704 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28705     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
28706 }
28707 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
28708     return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
28709 }
28710 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
28711     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28712 }
28713 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
28714     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28715 }
28716 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28717     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28718 }
28719 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28720     return (void *)((wxObject *)  ((wxSizerItem *) x));
28721 }
28722 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28723     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28724 }
28725 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28726     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
28727 }
28728 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28729     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28730 }
28731 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28732     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28733 }
28734 static void *_p_wxSizerTo_p_wxObject(void *x) {
28735     return (void *)((wxObject *)  ((wxSizer *) x));
28736 }
28737 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28738     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28739 }
28740 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28741     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28742 }
28743 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
28744     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28745 }
28746 static void *_p_wxEventTo_p_wxObject(void *x) {
28747     return (void *)((wxObject *)  ((wxEvent *) x));
28748 }
28749 static void *_p_wxFontDataTo_p_wxObject(void *x) {
28750     return (void *)((wxObject *)  ((wxFontData *) x));
28751 }
28752 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
28753     return (void *)((wxObject *)  ((wxPrintData *) x));
28754 }
28755 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28756     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28757 }
28758 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28759     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28760 }
28761 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28762     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28763 }
28764 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
28765     return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
28766 }
28767 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
28768     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
28769 }
28770 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
28771     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
28772 }
28773 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28774     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28775 }
28776 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28777     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28778 }
28779 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28780     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28781 }
28782 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28783     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28784 }
28785 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28786     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28787 }
28788 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28789     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28790 }
28791 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
28792     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28793 }
28794 static void *_p_wxControlTo_p_wxObject(void *x) {
28795     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28796 }
28797 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28798     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28799 }
28800 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
28801     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28802 }
28803 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28804     return (void *)((wxObject *)  ((wxFSFile *) x));
28805 }
28806 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
28807     return (void *)((wxObject *)  ((wxFindReplaceData *) x));
28808 }
28809 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28810     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28811 }
28812 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
28813     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28814 }
28815 static void *_p_wxColourDataTo_p_wxObject(void *x) {
28816     return (void *)((wxObject *)  ((wxColourData *) x));
28817 }
28818 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28819     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28820 }
28821 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28822     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28823 }
28824 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
28825     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
28826 }
28827 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
28828     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28829 }
28830 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
28831     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28832 }
28833 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
28834     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28835 }
28836 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
28837     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28838 }
28839 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
28840     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28841 }
28842 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
28843     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28844 }
28845 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
28846     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28847 }
28848 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
28849     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28850 }
28851 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
28852     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28853 }
28854 static void *_p_wxShowEventTo_p_wxObject(void *x) {
28855     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
28856 }
28857 static void *_p_wxPrinterTo_p_wxObject(void *x) {
28858     return (void *)((wxObject *)  ((wxPrinter *) x));
28859 }
28860 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
28861     return (void *)((wxObject *)  ((wxMenuItem *) x));
28862 }
28863 static void *_p_wxDateEventTo_p_wxObject(void *x) {
28864     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
28865 }
28866 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
28867     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
28868 }
28869 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
28870     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
28871 }
28872 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
28873     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
28874 }
28875 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
28876     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
28877 }
28878 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
28879     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
28880 }
28881 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
28882     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
28883 }
28884 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
28885     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
28886 }
28887 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
28888     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
28889 }
28890 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
28891     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
28892 }
28893 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
28894     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
28895 }
28896 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
28897     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
28898 }
28899 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
28900     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
28901 }
28902 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
28903     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
28904 }
28905 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
28906     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
28907 }
28908 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
28909     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
28910 }
28911 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
28912     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
28913 }
28914 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
28915     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
28916 }
28917 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
28918     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
28919 }
28920 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
28921     return (void *)((wxObject *)  ((wxImageHandler *) x));
28922 }
28923 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
28924     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
28925 }
28926 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
28927     return (void *)((wxObject *)  ((wxEvtHandler *) x));
28928 }
28929 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
28930     return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
28931 }
28932 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
28933     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28934 }
28935 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
28936     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28937 }
28938 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
28939     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
28940 }
28941 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
28942     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
28943 }
28944 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
28945     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28946 }
28947 static void *_p_wxImageTo_p_wxObject(void *x) {
28948     return (void *)((wxObject *)  ((wxImage *) x));
28949 }
28950 static void *_p_wxFrameTo_p_wxObject(void *x) {
28951     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28952 }
28953 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
28954     return (void *)((wxObject *)  ((wxPyPrintout *) x));
28955 }
28956 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
28957     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
28958 }
28959 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
28960     return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
28961 }
28962 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
28963     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
28964 }
28965 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
28966     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28967 }
28968 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
28969     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28970 }
28971 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
28972     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
28973 }
28974 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
28975     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
28976 }
28977 static void *_p_wxWindowTo_p_wxObject(void *x) {
28978     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
28979 }
28980 static void *_p_wxMenuTo_p_wxObject(void *x) {
28981     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
28982 }
28983 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
28984     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
28985 }
28986 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
28987     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28988 }
28989 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
28990     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
28991 }
28992 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
28993     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
28994 }
28995 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
28996     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
28997 }
28998 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
28999     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
29000 }
29001 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
29002     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
29003 }
29004 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
29005     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
29006 }
29007 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
29008     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29009 }
29010 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
29011     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29012 }
29013 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
29014     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
29015 }
29016 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
29017     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
29018 }
29019 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
29020     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29021 }
29022 static void *_p_wxSashEventTo_p_wxObject(void *x) {
29023     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
29024 }
29025 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
29026     return (void *)((wxObject *)  ((wxPrintPreview *) x));
29027 }
29028 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
29029     return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
29030 }
29031 static void *_p_wxPanelTo_p_wxObject(void *x) {
29032     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
29033 }
29034 static void *_p_wxDialogTo_p_wxObject(void *x) {
29035     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
29036 }
29037 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
29038     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29039 }
29040 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
29041     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29042 }
29043 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
29044     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29045 }
29046 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
29047     return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
29048 }
29049 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
29050     return (void *)((wxObject *)  ((wxPrintDialog *) x));
29051 }
29052 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29053     return (void *)((wxObject *)  ((wxFileSystem *) x));
29054 }
29055 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29056     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29057 }
29058 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29059     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29060 }
29061 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29062     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29063 }
29064 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29065     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29066 }
29067 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29068     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29069 }
29070 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29071     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29072 }
29073 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29074     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29075 }
29076 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29077     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29078 }
29079 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
29080     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
29081 }
29082 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
29083     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29084 }
29085 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29086     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29087 }
29088 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29089     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29090 }
29091 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29092     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29093 }
29094 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29095     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29096 }
29097 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
29098     return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
29099 }
29100 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
29101     return (void *)((wxObject *)  ((wxPrintDialogData *) x));
29102 }
29103 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29104     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29105 }
29106 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29107     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29108 }
29109 static void *_p_wxPyVListBoxTo_p_wxPyVScrolledWindow(void *x) {
29110     return (void *)((wxPyVScrolledWindow *)  ((wxPyVListBox *) x));
29111 }
29112 static void *_p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow(void *x) {
29113     return (void *)((wxPyVScrolledWindow *) (wxPyVListBox *) ((wxPyHtmlListBox *) x));
29114 }
29115 static void *_p_wxTipWindowTo_p_wxPyPopupTransientWindow(void *x) {
29116     return (void *)((wxPyPopupTransientWindow *)  ((wxTipWindow *) x));
29117 }
29118 static void *_p_wxPyPopupTransientWindowTo_p_wxPopupWindow(void *x) {
29119     return (void *)((wxPopupWindow *)  ((wxPyPopupTransientWindow *) x));
29120 }
29121 static void *_p_wxTipWindowTo_p_wxPopupWindow(void *x) {
29122     return (void *)((wxPopupWindow *) (wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29123 }
29124 static void *_p_wxSashLayoutWindowTo_p_wxSashWindow(void *x) {
29125     return (void *)((wxSashWindow *)  ((wxSashLayoutWindow *) x));
29126 }
29127 static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
29128     return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
29129 }
29130 static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
29131     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
29132 }
29133 static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
29134     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
29135 }
29136 static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
29137     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
29138 }
29139 static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
29140     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
29141 }
29142 static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
29143     return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
29144 }
29145 static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
29146     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
29147 }
29148 static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
29149     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
29150 }
29151 static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
29152     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
29153 }
29154 static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
29155     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxProgressDialog *) x));
29156 }
29157 static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
29158     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
29159 }
29160 static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
29161     return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29162 }
29163 static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
29164     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
29165 }
29166 static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29167     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
29168 }
29169 static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29170     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
29171 }
29172 static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
29173     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
29174 }
29175 static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
29176     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
29177 }
29178 static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29179     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
29180 }
29181 static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29182     return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29183 }
29184 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
29185     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
29186 }
29187 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
29188     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29189 }
29190 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
29191     return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
29192 }
29193 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29194     return (void *)((wxWindow *)  ((wxMenuBar *) x));
29195 }
29196 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
29197     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29198 }
29199 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
29200     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29201 }
29202 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
29203     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29204 }
29205 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
29206     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29207 }
29208 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
29209     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
29210 }
29211 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
29212     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
29213 }
29214 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
29215     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
29216 }
29217 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
29218     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
29219 }
29220 static void *_p_wxPanelTo_p_wxWindow(void *x) {
29221     return (void *)((wxWindow *)  ((wxPanel *) x));
29222 }
29223 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
29224     return (void *)((wxWindow *)  ((wxStatusBar *) x));
29225 }
29226 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
29227     return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
29228 }
29229 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
29230     return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29231 }
29232 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
29233     return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29234 }
29235 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
29236     return (void *)((wxWindow *)  ((wxPopupWindow *) x));
29237 }
29238 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
29239     return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
29240 }
29241 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
29242     return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
29243 }
29244 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
29245     return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
29246 }
29247 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
29248     return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
29249 }
29250 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
29251     return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
29252 }
29253 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
29254     return (void *)((wxWindow *)  ((wxSashWindow *) x));
29255 }
29256 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
29257     return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
29258 }
29259 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
29260     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29261 }
29262 static void *_p_wxControlTo_p_wxWindow(void *x) {
29263     return (void *)((wxWindow *)  ((wxControl *) x));
29264 }
29265 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
29266     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
29267 }
29268 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
29269     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29270 }
29271 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
29272     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
29273 }
29274 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29275     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29276 }
29277 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
29278     return (void *)((wxWindow *)  ((wxPyWindow *) x));
29279 }
29280 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
29281     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
29282 }
29283 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
29284     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29285 }
29286 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
29287     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29288 }
29289 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
29290     return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
29291 }
29292 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
29293     return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29294 }
29295 static void *_p_wxFrameTo_p_wxWindow(void *x) {
29296     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
29297 }
29298 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
29299     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29300 }
29301 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
29302     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29303 }
29304 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
29305     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29306 }
29307 static void *_p_wxDialogTo_p_wxWindow(void *x) {
29308     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
29309 }
29310 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
29311     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29312 }
29313 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
29314     return (void *)((wxScrolledWindow *)  ((wxPyScrolledWindow *) x));
29315 }
29316 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
29317     return (void *)((wxScrolledWindow *)  ((wxPreviewCanvas *) x));
29318 }
29319 static void *_p_wxPyPrintPreviewTo_p_wxPrintPreview(void *x) {
29320     return (void *)((wxPrintPreview *)  ((wxPyPrintPreview *) x));
29321 }
29322 static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
29323     return (void *)((wxDialog *)  ((wxColourDialog *) x));
29324 }
29325 static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
29326     return (void *)((wxDialog *)  ((wxDirDialog *) x));
29327 }
29328 static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
29329     return (void *)((wxDialog *)  ((wxFontDialog *) x));
29330 }
29331 static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
29332     return (void *)((wxDialog *)  ((wxFileDialog *) x));
29333 }
29334 static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
29335     return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
29336 }
29337 static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
29338     return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
29339 }
29340 static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
29341     return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
29342 }
29343 static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
29344     return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29345 }
29346 static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
29347     return (void *)((wxDialog *)  ((wxMessageDialog *) x));
29348 }
29349 static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
29350     return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
29351 }
29352 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
29353     return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
29354 }
29355 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
29356     return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
29357 }
29358 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
29359     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29360 }
29361 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
29362     return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29363 }
29364 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
29365     return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29366 }
29367 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
29368     return (void *)((wxPanel *)  ((wxPyPanel *) x));
29369 }
29370 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
29371     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
29372 }
29373 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
29374     return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
29375 }
29376 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
29377     return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29378 }
29379 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
29380     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
29381 }
29382 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
29383     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
29384 }
29385 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
29386     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
29387 }
29388 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
29389     return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
29390 }
29391 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
29392     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
29393 }
29394 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
29395     return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
29396 }
29397 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
29398     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
29399 }
29400 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
29401     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
29402 }
29403 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
29404     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
29405 }
29406 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
29407     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
29408 }
29409 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
29410     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
29411 }
29412 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
29413     return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
29414 }
29415 static void *_p_wxPyPreviewControlBarTo_p_wxPreviewControlBar(void *x) {
29416     return (void *)((wxPreviewControlBar *)  ((wxPyPreviewControlBar *) x));
29417 }
29418 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}};
29419 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}};
29420 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}};
29421 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}};
29422 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}};
29423 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}};
29424 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}};
29425 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}};
29426 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}};
29427 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}};
29428 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}};
29429 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}};
29430 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}};
29431 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}};
29432 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}};
29433 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}};
29434 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}};
29435 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}};
29436 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}};
29437 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}};
29438 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}};
29439 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}};
29440 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}};
29441 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}};
29442 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}};
29443 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}};
29444 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}};
29445 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}};
29446 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}};
29447 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}};
29448 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}};
29449 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}};
29450 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}};
29451 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}};
29452 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}};
29453 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}};
29454 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}};
29455 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}};
29456 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}};
29457 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}};
29458 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}};
29459 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}};
29460 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}};
29461 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}};
29462 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}};
29463 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}};
29464 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}};
29465 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}};
29466 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}};
29467 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}};
29468 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}};
29469 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}};
29470 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}};
29471 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}};
29472 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}};
29473 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}};
29474 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}};
29475 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}};
29476 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}};
29477 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}};
29478 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}};
29479 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}};
29480 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}};
29481 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}};
29482 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}};
29483 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}};
29484 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}};
29485 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}};
29486 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}};
29487 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}};
29488 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}};
29489 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}};
29490 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}};
29491 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}};
29492 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}};
29493 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}};
29494 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}};
29495 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}};
29496 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}};
29497 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}};
29498 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}};
29499 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}};
29500 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}};
29501 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}};
29502 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}};
29503 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}};
29504 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}};
29505 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}};
29506 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}};
29507 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}};
29508 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}};
29509 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}};
29510 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}};
29511 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}};
29512 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}};
29513 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}};
29514 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}};
29515
29516 static swig_type_info *swig_types_initial[] = {
29517 _swigt__p_wxQueryLayoutInfoEvent,
29518 _swigt__p_wxPreviewFrame,
29519 _swigt__p_wxPyPreviewFrame,
29520 _swigt__p_wxPyPanel,
29521 _swigt__p_wxMenu,
29522 _swigt__p_wxFontData,
29523 _swigt__p_wxEvent,
29524 _swigt__p_wxPrintData,
29525 _swigt__p_wxTaskBarIcon,
29526 _swigt__p_wxPyTaskBarIcon,
29527 _swigt__p_wxIconBundle,
29528 _swigt__p_wxLayoutAlgorithm,
29529 _swigt__p_wxFindDialogEvent,
29530 _swigt__p_wxPreviewCanvas,
29531 _swigt__p_wxFont,
29532 _swigt__p_wxSplitterEvent,
29533 _swigt__p_wxRegion,
29534 _swigt__ptrdiff_t,
29535 _swigt__std__ptrdiff_t,
29536 _swigt__p_wxFindReplaceData,
29537 _swigt__p_int,
29538 _swigt__p_wxSize,
29539 _swigt__p_wxDC,
29540 _swigt__p_wxIcon,
29541 _swigt__p_wxVisualAttributes,
29542 _swigt__p_wxMDIChildFrame,
29543 _swigt__p_wxColourData,
29544 _swigt__p_wxNotifyEvent,
29545 _swigt__p_wxPyWindow,
29546 _swigt__p_form_ops_t,
29547 _swigt__p_wxSplashScreen,
29548 _swigt__p_wxPasswordEntryDialog,
29549 _swigt__p_wxSingleChoiceDialog,
29550 _swigt__p_wxMultiChoiceDialog,
29551 _swigt__p_wxFileDialog,
29552 _swigt__p_wxTextEntryDialog,
29553 _swigt__p_wxMessageDialog,
29554 _swigt__p_wxProgressDialog,
29555 _swigt__p_wxFindReplaceDialog,
29556 _swigt__p_wxPrinter,
29557 _swigt__p_wxArrayInt,
29558 _swigt__p_wxDuplexMode,
29559 _swigt__p_wxEvtHandler,
29560 _swigt__p_wxCalculateLayoutEvent,
29561 _swigt__p_wxPyHtmlListBox,
29562 _swigt__p_wxPyVListBox,
29563 _swigt__p_wxRect,
29564 _swigt__p_wxStdDialogButtonSizer,
29565 _swigt__p_char,
29566 _swigt__p_wxMiniFrame,
29567 _swigt__p_wxFrame,
29568 _swigt__p_wxPyPrintout,
29569 _swigt__p_wxTaskBarIconEvent,
29570 _swigt__p_wxScrollWinEvent,
29571 _swigt__p_wxPaperSize,
29572 _swigt__p_wxStatusBar,
29573 _swigt__p_wxMDIParentFrame,
29574 _swigt__p_wxPoint,
29575 _swigt__p_wxObject,
29576 _swigt__p_unsigned_long,
29577 _swigt__p_wxTipWindow,
29578 _swigt__p_wxSashLayoutWindow,
29579 _swigt__p_wxSplitterWindow,
29580 _swigt__p_wxSplashScreenWindow,
29581 _swigt__p_wxPyVScrolledWindow,
29582 _swigt__p_wxPyPopupTransientWindow,
29583 _swigt__p_wxPopupWindow,
29584 _swigt__p_wxSashWindow,
29585 _swigt__p_wxTopLevelWindow,
29586 _swigt__p_wxWindow,
29587 _swigt__p_wxScrolledWindow,
29588 _swigt__p_wxMenuBar,
29589 _swigt__p_wxMDIClientWindow,
29590 _swigt__p_wxPyScrolledWindow,
29591 _swigt__p_wxPrintPreview,
29592 _swigt__p_wxSashEvent,
29593 _swigt__p_wxString,
29594 _swigt__p_wxPyPrintPreview,
29595 _swigt__p_wxDirDialog,
29596 _swigt__p_wxColourDialog,
29597 _swigt__p_wxDialog,
29598 _swigt__p_wxPanel,
29599 _swigt__p_wxFontDialog,
29600 _swigt__p_wxPageSetupDialog,
29601 _swigt__p_wxPrintDialog,
29602 _swigt__p_wxFileSystem,
29603 _swigt__p_wxBitmap,
29604 _swigt__unsigned_int,
29605 _swigt__p_unsigned_int,
29606 _swigt__p_unsigned_char,
29607 _swigt__p_wxCommandEvent,
29608 _swigt__p_wxPreviewControlBar,
29609 _swigt__p_wxPyPreviewControlBar,
29610 _swigt__p_wxColour,
29611 _swigt__p_wxToolBar,
29612 _swigt__p_wxPageSetupDialogData,
29613 _swigt__p_wxPrintDialogData,
29614 0
29615 };
29616
29617
29618 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29619
29620 static swig_const_info swig_const_table[] = {
29621 {0, 0, 0, 0.0, 0, 0}};
29622
29623 #ifdef __cplusplus
29624 }
29625 #endif
29626
29627
29628 #ifdef __cplusplus
29629 extern "C" {
29630 #endif
29631
29632     /* Python-specific SWIG API */
29633 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
29634 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29635 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
29636
29637     /* -----------------------------------------------------------------------------
29638      * global variable support code.
29639      * ----------------------------------------------------------------------------- */
29640
29641     typedef struct swig_globalvar {
29642         char       *name;                  /* Name of global variable */
29643         PyObject *(*get_attr)();           /* Return the current value */
29644         int       (*set_attr)(PyObject *); /* Set the value */
29645         struct swig_globalvar *next;
29646     } swig_globalvar;
29647
29648     typedef struct swig_varlinkobject {
29649         PyObject_HEAD
29650         swig_globalvar *vars;
29651     } swig_varlinkobject;
29652
29653     static PyObject *
29654     swig_varlink_repr(swig_varlinkobject *v) {
29655         v = v;
29656         return PyString_FromString("<Swig global variables>");
29657     }
29658
29659     static int
29660     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
29661         swig_globalvar  *var;
29662         flags = flags;
29663         fprintf(fp,"Swig global variables { ");
29664         for (var = v->vars; var; var=var->next) {
29665             fprintf(fp,"%s", var->name);
29666             if (var->next) fprintf(fp,", ");
29667         }
29668         fprintf(fp," }\n");
29669         return 0;
29670     }
29671
29672     static PyObject *
29673     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29674         swig_globalvar *var = v->vars;
29675         while (var) {
29676             if (strcmp(var->name,n) == 0) {
29677                 return (*var->get_attr)();
29678             }
29679             var = var->next;
29680         }
29681         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29682         return NULL;
29683     }
29684
29685     static int
29686     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29687         swig_globalvar *var = v->vars;
29688         while (var) {
29689             if (strcmp(var->name,n) == 0) {
29690                 return (*var->set_attr)(p);
29691             }
29692             var = var->next;
29693         }
29694         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29695         return 1;
29696     }
29697
29698     static PyTypeObject varlinktype = {
29699         PyObject_HEAD_INIT(0)
29700         0,                                  /* Number of items in variable part (ob_size) */
29701         (char *)"swigvarlink",              /* Type name (tp_name) */
29702         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
29703         0,                                  /* Itemsize (tp_itemsize) */
29704         0,                                  /* Deallocator (tp_dealloc) */
29705         (printfunc) swig_varlink_print,     /* Print (tp_print) */
29706         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29707         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
29708         0,                                  /* tp_compare */
29709         (reprfunc) swig_varlink_repr,       /* tp_repr */
29710         0,                                  /* tp_as_number */
29711         0,                                  /* tp_as_sequence */
29712         0,                                  /* tp_as_mapping */
29713         0,                                  /* tp_hash */
29714         0,                                  /* tp_call */
29715         0,                                  /* tp_str */
29716         0,                                  /* tp_getattro */
29717         0,                                  /* tp_setattro */
29718         0,                                  /* tp_as_buffer */
29719         0,                                  /* tp_flags */
29720         0,                                  /* tp_doc */
29721 #if PY_VERSION_HEX >= 0x02000000
29722         0,                                  /* tp_traverse */
29723         0,                                  /* tp_clear */
29724 #endif
29725 #if PY_VERSION_HEX >= 0x02010000
29726         0,                                  /* tp_richcompare */
29727         0,                                  /* tp_weaklistoffset */
29728 #endif
29729 #if PY_VERSION_HEX >= 0x02020000
29730         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
29731 #endif
29732 #if PY_VERSION_HEX >= 0x02030000
29733         0,                                  /* tp_del */
29734 #endif
29735 #ifdef COUNT_ALLOCS
29736         0,0,0,0                             /* tp_alloc -> tp_next */
29737 #endif
29738     };
29739
29740     /* Create a variable linking object for use later */
29741     static PyObject *
29742     SWIG_Python_newvarlink(void) {
29743         swig_varlinkobject *result = 0;
29744         result = PyMem_NEW(swig_varlinkobject,1);
29745         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
29746         result->ob_type = &varlinktype;
29747         result->vars = 0;
29748         result->ob_refcnt = 0;
29749         Py_XINCREF((PyObject *) result);
29750         return ((PyObject*) result);
29751     }
29752
29753     static void
29754     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
29755         swig_varlinkobject *v;
29756         swig_globalvar *gv;
29757         v= (swig_varlinkobject *) p;
29758         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
29759         gv->name = (char *) malloc(strlen(name)+1);
29760         strcpy(gv->name,name);
29761         gv->get_attr = get_attr;
29762         gv->set_attr = set_attr;
29763         gv->next = v->vars;
29764         v->vars = gv;
29765     }
29766
29767     /* -----------------------------------------------------------------------------
29768      * constants/methods manipulation
29769      * ----------------------------------------------------------------------------- */
29770
29771     /* Install Constants */
29772     static void
29773     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
29774         PyObject *obj = 0;
29775         size_t i;
29776         for (i = 0; constants[i].type; i++) {
29777             switch(constants[i].type) {
29778                 case SWIG_PY_INT:
29779                 obj = PyInt_FromLong(constants[i].lvalue);
29780                 break;
29781                 case SWIG_PY_FLOAT:
29782                 obj = PyFloat_FromDouble(constants[i].dvalue);
29783                 break;
29784                 case SWIG_PY_STRING:
29785                 if (constants[i].pvalue) {
29786                     obj = PyString_FromString((char *) constants[i].pvalue);
29787                 } else {
29788                     Py_INCREF(Py_None);
29789                     obj = Py_None;
29790                 }
29791                 break;
29792                 case SWIG_PY_POINTER:
29793                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
29794                 break;
29795                 case SWIG_PY_BINARY:
29796                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
29797                 break;
29798                 default:
29799                 obj = 0;
29800                 break;
29801             }
29802             if (obj) {
29803                 PyDict_SetItemString(d,constants[i].name,obj);
29804                 Py_DECREF(obj);
29805             }
29806         }
29807     }
29808
29809     /* -----------------------------------------------------------------------------*/
29810     /* Fix SwigMethods to carry the callback ptrs when needed */
29811     /* -----------------------------------------------------------------------------*/
29812
29813     static void
29814     SWIG_Python_FixMethods(PyMethodDef *methods,
29815     swig_const_info *const_table,
29816     swig_type_info **types,
29817     swig_type_info **types_initial) {
29818         size_t i;
29819         for (i = 0; methods[i].ml_name; ++i) {
29820             char *c = methods[i].ml_doc;
29821             if (c && (c = strstr(c, "swig_ptr: "))) {
29822                 int j;
29823                 swig_const_info *ci = 0;
29824                 char *name = c + 10;
29825                 for (j = 0; const_table[j].type; j++) {
29826                     if (strncmp(const_table[j].name, name,
29827                     strlen(const_table[j].name)) == 0) {
29828                         ci = &(const_table[j]);
29829                         break;
29830                     }
29831                 }
29832                 if (ci) {
29833                     size_t shift = (ci->ptype) - types;
29834                     swig_type_info *ty = types_initial[shift];
29835                     size_t ldoc = (c - methods[i].ml_doc);
29836                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
29837                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
29838                     char *buff = ndoc;
29839                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
29840                     strncpy(buff, methods[i].ml_doc, ldoc);
29841                     buff += ldoc;
29842                     strncpy(buff, "swig_ptr: ", 10);
29843                     buff += 10;
29844                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
29845                     methods[i].ml_doc = ndoc;
29846                 }
29847             }
29848         }
29849     }
29850
29851     /* -----------------------------------------------------------------------------*
29852      *  Initialize type list
29853      * -----------------------------------------------------------------------------*/
29854
29855 #if PY_MAJOR_VERSION < 2
29856     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
29857     is copied out of Python/modsupport.c in python version 2.3.4 */
29858     static int
29859     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
29860     {
29861         PyObject *dict;
29862         if (!PyModule_Check(m)) {
29863             PyErr_SetString(PyExc_TypeError,
29864             "PyModule_AddObject() needs module as first arg");
29865             return -1;
29866         }
29867         if (!o) {
29868             PyErr_SetString(PyExc_TypeError,
29869             "PyModule_AddObject() needs non-NULL value");
29870             return -1;
29871         }
29872
29873         dict = PyModule_GetDict(m);
29874         if (dict == NULL) {
29875             /* Internal error -- modules must have a dict! */
29876             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
29877             PyModule_GetName(m));
29878             return -1;
29879         }
29880         if (PyDict_SetItemString(dict, name, o))
29881         return -1;
29882         Py_DECREF(o);
29883         return 0;
29884     }
29885 #endif
29886
29887     static swig_type_info **
29888     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
29889         static PyMethodDef swig_empty_runtime_method_table[] = {
29890             {
29891                 NULL, NULL, 0, NULL
29892             }
29893         };/* Sentinel */
29894
29895         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
29896         swig_empty_runtime_method_table);
29897         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
29898         if (pointer && module) {
29899             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
29900         }
29901         return type_list_handle;
29902     }
29903
29904     static swig_type_info **
29905     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
29906         swig_type_info **type_pointer;
29907
29908         /* first check if module already created */
29909         type_pointer = SWIG_Python_GetTypeListHandle();
29910         if (type_pointer) {
29911             return type_pointer;
29912         } else {
29913             /* create a new module and variable */
29914             return SWIG_Python_SetTypeListHandle(type_list_handle);
29915         }
29916     }
29917
29918 #ifdef __cplusplus
29919 }
29920 #endif
29921
29922 /* -----------------------------------------------------------------------------*
29923  *  Partial Init method
29924  * -----------------------------------------------------------------------------*/
29925
29926 #ifdef SWIG_LINK_RUNTIME
29927 #ifdef __cplusplus
29928 extern "C"
29929 #endif
29930 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
29931 #endif
29932
29933 #ifdef __cplusplus
29934 extern "C"
29935 #endif
29936 SWIGEXPORT(void) SWIG_init(void) {
29937     static PyObject *SWIG_globals = 0;
29938     static int       typeinit = 0;
29939     PyObject *m, *d;
29940     int       i;
29941     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
29942
29943     /* Fix SwigMethods to carry the callback ptrs when needed */
29944     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
29945
29946     m = Py_InitModule((char *) SWIG_name, SwigMethods);
29947     d = PyModule_GetDict(m);
29948
29949     if (!typeinit) {
29950 #ifdef SWIG_LINK_RUNTIME
29951         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
29952 #else
29953 #  ifndef SWIG_STATIC_RUNTIME
29954         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
29955 #  endif
29956 #endif
29957         for (i = 0; swig_types_initial[i]; i++) {
29958             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
29959         }
29960         typeinit = 1;
29961     }
29962     SWIG_InstallConstants(d,swig_const_table);
29963
29964     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
29965     SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
29966     SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
29967     SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
29968     SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
29969     {
29970         PyDict_SetItemString(d,"STAY_ON_TOP", SWIG_From_int((int)(wxSTAY_ON_TOP)));
29971     }
29972     {
29973         PyDict_SetItemString(d,"ICONIZE", SWIG_From_int((int)(wxICONIZE)));
29974     }
29975     {
29976         PyDict_SetItemString(d,"MINIMIZE", SWIG_From_int((int)(wxMINIMIZE)));
29977     }
29978     {
29979         PyDict_SetItemString(d,"MAXIMIZE", SWIG_From_int((int)(wxMAXIMIZE)));
29980     }
29981     {
29982         PyDict_SetItemString(d,"CLOSE_BOX", SWIG_From_int((int)(wxCLOSE_BOX)));
29983     }
29984     {
29985         PyDict_SetItemString(d,"THICK_FRAME", SWIG_From_int((int)(wxTHICK_FRAME)));
29986     }
29987     {
29988         PyDict_SetItemString(d,"SYSTEM_MENU", SWIG_From_int((int)(wxSYSTEM_MENU)));
29989     }
29990     {
29991         PyDict_SetItemString(d,"MINIMIZE_BOX", SWIG_From_int((int)(wxMINIMIZE_BOX)));
29992     }
29993     {
29994         PyDict_SetItemString(d,"MAXIMIZE_BOX", SWIG_From_int((int)(wxMAXIMIZE_BOX)));
29995     }
29996     {
29997         PyDict_SetItemString(d,"TINY_CAPTION_HORIZ", SWIG_From_int((int)(wxTINY_CAPTION_HORIZ)));
29998     }
29999     {
30000         PyDict_SetItemString(d,"TINY_CAPTION_VERT", SWIG_From_int((int)(wxTINY_CAPTION_VERT)));
30001     }
30002     {
30003         PyDict_SetItemString(d,"RESIZE_BOX", SWIG_From_int((int)(wxRESIZE_BOX)));
30004     }
30005     {
30006         PyDict_SetItemString(d,"RESIZE_BORDER", SWIG_From_int((int)(wxRESIZE_BORDER)));
30007     }
30008     {
30009         PyDict_SetItemString(d,"DIALOG_NO_PARENT", SWIG_From_int((int)(wxDIALOG_NO_PARENT)));
30010     }
30011     {
30012         PyDict_SetItemString(d,"DEFAULT_FRAME_STYLE", SWIG_From_int((int)(wxDEFAULT_FRAME_STYLE)));
30013     }
30014     {
30015         PyDict_SetItemString(d,"DEFAULT_DIALOG_STYLE", SWIG_From_int((int)(wxDEFAULT_DIALOG_STYLE)));
30016     }
30017     {
30018         PyDict_SetItemString(d,"FRAME_TOOL_WINDOW", SWIG_From_int((int)(wxFRAME_TOOL_WINDOW)));
30019     }
30020     {
30021         PyDict_SetItemString(d,"FRAME_FLOAT_ON_PARENT", SWIG_From_int((int)(wxFRAME_FLOAT_ON_PARENT)));
30022     }
30023     {
30024         PyDict_SetItemString(d,"FRAME_NO_WINDOW_MENU", SWIG_From_int((int)(wxFRAME_NO_WINDOW_MENU)));
30025     }
30026     {
30027         PyDict_SetItemString(d,"FRAME_NO_TASKBAR", SWIG_From_int((int)(wxFRAME_NO_TASKBAR)));
30028     }
30029     {
30030         PyDict_SetItemString(d,"FRAME_SHAPED", SWIG_From_int((int)(wxFRAME_SHAPED)));
30031     }
30032     {
30033         PyDict_SetItemString(d,"FRAME_DRAWER", SWIG_From_int((int)(wxFRAME_DRAWER)));
30034     }
30035     {
30036         PyDict_SetItemString(d,"FRAME_EX_METAL", SWIG_From_int((int)(wxFRAME_EX_METAL)));
30037     }
30038     {
30039         PyDict_SetItemString(d,"DIALOG_EX_METAL", SWIG_From_int((int)(wxDIALOG_EX_METAL)));
30040     }
30041     {
30042         PyDict_SetItemString(d,"DIALOG_MODAL", SWIG_From_int((int)(wxDIALOG_MODAL)));
30043     }
30044     {
30045         PyDict_SetItemString(d,"DIALOG_MODELESS", SWIG_From_int((int)(wxDIALOG_MODELESS)));
30046     }
30047     {
30048         PyDict_SetItemString(d,"USER_COLOURS", SWIG_From_int((int)(wxUSER_COLOURS)));
30049     }
30050     {
30051         PyDict_SetItemString(d,"NO_3D", SWIG_From_int((int)(wxNO_3D)));
30052     }
30053     {
30054         PyDict_SetItemString(d,"FULLSCREEN_NOMENUBAR", SWIG_From_int((int)(wxFULLSCREEN_NOMENUBAR)));
30055     }
30056     {
30057         PyDict_SetItemString(d,"FULLSCREEN_NOTOOLBAR", SWIG_From_int((int)(wxFULLSCREEN_NOTOOLBAR)));
30058     }
30059     {
30060         PyDict_SetItemString(d,"FULLSCREEN_NOSTATUSBAR", SWIG_From_int((int)(wxFULLSCREEN_NOSTATUSBAR)));
30061     }
30062     {
30063         PyDict_SetItemString(d,"FULLSCREEN_NOBORDER", SWIG_From_int((int)(wxFULLSCREEN_NOBORDER)));
30064     }
30065     {
30066         PyDict_SetItemString(d,"FULLSCREEN_NOCAPTION", SWIG_From_int((int)(wxFULLSCREEN_NOCAPTION)));
30067     }
30068     {
30069         PyDict_SetItemString(d,"FULLSCREEN_ALL", SWIG_From_int((int)(wxFULLSCREEN_ALL)));
30070     }
30071     {
30072         PyDict_SetItemString(d,"TOPLEVEL_EX_DIALOG", SWIG_From_int((int)(wxTOPLEVEL_EX_DIALOG)));
30073     }
30074     {
30075         PyDict_SetItemString(d,"USER_ATTENTION_INFO", SWIG_From_int((int)(wxUSER_ATTENTION_INFO)));
30076     }
30077     {
30078         PyDict_SetItemString(d,"USER_ATTENTION_ERROR", SWIG_From_int((int)(wxUSER_ATTENTION_ERROR)));
30079     }
30080     {
30081         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_PARENT", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_PARENT)));
30082     }
30083     {
30084         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_SCREEN", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_SCREEN)));
30085     }
30086     {
30087         PyDict_SetItemString(d,"SPLASH_NO_CENTRE", SWIG_From_int((int)(wxSPLASH_NO_CENTRE)));
30088     }
30089     {
30090         PyDict_SetItemString(d,"SPLASH_TIMEOUT", SWIG_From_int((int)(wxSPLASH_TIMEOUT)));
30091     }
30092     {
30093         PyDict_SetItemString(d,"SPLASH_NO_TIMEOUT", SWIG_From_int((int)(wxSPLASH_NO_TIMEOUT)));
30094     }
30095     {
30096         PyDict_SetItemString(d,"SB_NORMAL", SWIG_From_int((int)(wxSB_NORMAL)));
30097     }
30098     {
30099         PyDict_SetItemString(d,"SB_FLAT", SWIG_From_int((int)(wxSB_FLAT)));
30100     }
30101     {
30102         PyDict_SetItemString(d,"SB_RAISED", SWIG_From_int((int)(wxSB_RAISED)));
30103     }
30104     SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
30105     {
30106         PyDict_SetItemString(d,"SP_NOBORDER", SWIG_From_int((int)(wxSP_NOBORDER)));
30107     }
30108     {
30109         PyDict_SetItemString(d,"SP_NOSASH", SWIG_From_int((int)(wxSP_NOSASH)));
30110     }
30111     {
30112         PyDict_SetItemString(d,"SP_PERMIT_UNSPLIT", SWIG_From_int((int)(wxSP_PERMIT_UNSPLIT)));
30113     }
30114     {
30115         PyDict_SetItemString(d,"SP_LIVE_UPDATE", SWIG_From_int((int)(wxSP_LIVE_UPDATE)));
30116     }
30117     {
30118         PyDict_SetItemString(d,"SP_3DSASH", SWIG_From_int((int)(wxSP_3DSASH)));
30119     }
30120     {
30121         PyDict_SetItemString(d,"SP_3DBORDER", SWIG_From_int((int)(wxSP_3DBORDER)));
30122     }
30123     {
30124         PyDict_SetItemString(d,"SP_NO_XP_THEME", SWIG_From_int((int)(wxSP_NO_XP_THEME)));
30125     }
30126     {
30127         PyDict_SetItemString(d,"SP_BORDER", SWIG_From_int((int)(wxSP_BORDER)));
30128     }
30129     {
30130         PyDict_SetItemString(d,"SP_3D", SWIG_From_int((int)(wxSP_3D)));
30131     }
30132     {
30133         PyDict_SetItemString(d,"SPLIT_HORIZONTAL", SWIG_From_int((int)(wxSPLIT_HORIZONTAL)));
30134     }
30135     {
30136         PyDict_SetItemString(d,"SPLIT_VERTICAL", SWIG_From_int((int)(wxSPLIT_VERTICAL)));
30137     }
30138     {
30139         PyDict_SetItemString(d,"SPLIT_DRAG_NONE", SWIG_From_int((int)(wxSPLIT_DRAG_NONE)));
30140     }
30141     {
30142         PyDict_SetItemString(d,"SPLIT_DRAG_DRAGGING", SWIG_From_int((int)(wxSPLIT_DRAG_DRAGGING)));
30143     }
30144     {
30145         PyDict_SetItemString(d,"SPLIT_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSPLIT_DRAG_LEFT_DOWN)));
30146     }
30147     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
30148     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
30149     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
30150     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
30151     SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
30152     SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
30153     {
30154         PyDict_SetItemString(d,"SASH_DRAG_NONE", SWIG_From_int((int)(wxSASH_DRAG_NONE)));
30155     }
30156     {
30157         PyDict_SetItemString(d,"SASH_DRAG_DRAGGING", SWIG_From_int((int)(wxSASH_DRAG_DRAGGING)));
30158     }
30159     {
30160         PyDict_SetItemString(d,"SASH_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSASH_DRAG_LEFT_DOWN)));
30161     }
30162     {
30163         PyDict_SetItemString(d,"SW_NOBORDER", SWIG_From_int((int)(wxSW_NOBORDER)));
30164     }
30165     {
30166         PyDict_SetItemString(d,"SW_BORDER", SWIG_From_int((int)(wxSW_BORDER)));
30167     }
30168     {
30169         PyDict_SetItemString(d,"SW_3DSASH", SWIG_From_int((int)(wxSW_3DSASH)));
30170     }
30171     {
30172         PyDict_SetItemString(d,"SW_3DBORDER", SWIG_From_int((int)(wxSW_3DBORDER)));
30173     }
30174     {
30175         PyDict_SetItemString(d,"SW_3D", SWIG_From_int((int)(wxSW_3D)));
30176     }
30177     {
30178         PyDict_SetItemString(d,"SASH_TOP", SWIG_From_int((int)(wxSASH_TOP)));
30179     }
30180     {
30181         PyDict_SetItemString(d,"SASH_RIGHT", SWIG_From_int((int)(wxSASH_RIGHT)));
30182     }
30183     {
30184         PyDict_SetItemString(d,"SASH_BOTTOM", SWIG_From_int((int)(wxSASH_BOTTOM)));
30185     }
30186     {
30187         PyDict_SetItemString(d,"SASH_LEFT", SWIG_From_int((int)(wxSASH_LEFT)));
30188     }
30189     {
30190         PyDict_SetItemString(d,"SASH_NONE", SWIG_From_int((int)(wxSASH_NONE)));
30191     }
30192     {
30193         PyDict_SetItemString(d,"SASH_STATUS_OK", SWIG_From_int((int)(wxSASH_STATUS_OK)));
30194     }
30195     {
30196         PyDict_SetItemString(d,"SASH_STATUS_OUT_OF_RANGE", SWIG_From_int((int)(wxSASH_STATUS_OUT_OF_RANGE)));
30197     }
30198     PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
30199     {
30200         PyDict_SetItemString(d,"LAYOUT_HORIZONTAL", SWIG_From_int((int)(wxLAYOUT_HORIZONTAL)));
30201     }
30202     {
30203         PyDict_SetItemString(d,"LAYOUT_VERTICAL", SWIG_From_int((int)(wxLAYOUT_VERTICAL)));
30204     }
30205     {
30206         PyDict_SetItemString(d,"LAYOUT_NONE", SWIG_From_int((int)(wxLAYOUT_NONE)));
30207     }
30208     {
30209         PyDict_SetItemString(d,"LAYOUT_TOP", SWIG_From_int((int)(wxLAYOUT_TOP)));
30210     }
30211     {
30212         PyDict_SetItemString(d,"LAYOUT_LEFT", SWIG_From_int((int)(wxLAYOUT_LEFT)));
30213     }
30214     {
30215         PyDict_SetItemString(d,"LAYOUT_RIGHT", SWIG_From_int((int)(wxLAYOUT_RIGHT)));
30216     }
30217     {
30218         PyDict_SetItemString(d,"LAYOUT_BOTTOM", SWIG_From_int((int)(wxLAYOUT_BOTTOM)));
30219     }
30220     {
30221         PyDict_SetItemString(d,"LAYOUT_LENGTH_Y", SWIG_From_int((int)(wxLAYOUT_LENGTH_Y)));
30222     }
30223     {
30224         PyDict_SetItemString(d,"LAYOUT_LENGTH_X", SWIG_From_int((int)(wxLAYOUT_LENGTH_X)));
30225     }
30226     {
30227         PyDict_SetItemString(d,"LAYOUT_MRU_LENGTH", SWIG_From_int((int)(wxLAYOUT_MRU_LENGTH)));
30228     }
30229     {
30230         PyDict_SetItemString(d,"LAYOUT_QUERY", SWIG_From_int((int)(wxLAYOUT_QUERY)));
30231     }
30232     PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
30233     PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
30234     SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
30235
30236     // Map renamed classes back to their common name for OOR
30237     wxPyPtrTypeMap_Add("wxHtmlListBox",     "wxPyHtmlListBox");
30238     wxPyPtrTypeMap_Add("wxVListBox",        "wxPyVListBox");
30239     wxPyPtrTypeMap_Add("wxVScrolledWindow", "wxPyVScrolledWindow");
30240
30241     PyDict_SetItemString(d, "wxEVT_TASKBAR_MOVE", PyInt_FromLong(wxEVT_TASKBAR_MOVE));
30242     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DOWN));
30243     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_UP", PyInt_FromLong(wxEVT_TASKBAR_LEFT_UP));
30244     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DOWN));
30245     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
30246     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
30247     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
30248     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
30249     SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
30250     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
30251     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
30252     SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
30253     SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
30254     {
30255         PyDict_SetItemString(d,"CHOICEDLG_STYLE", SWIG_From_int((int)(wxCHOICEDLG_STYLE)));
30256     }
30257     {
30258         PyDict_SetItemString(d,"TextEntryDialogStyle", SWIG_From_int((int)(wxTextEntryDialogStyle)));
30259     }
30260     SWIG_addvarlink(SWIG_globals,(char*)"GetPasswordFromUserPromptStr",_wrap_GetPasswordFromUserPromptStr_get, _wrap_GetPasswordFromUserPromptStr_set);
30261     {
30262         PyDict_SetItemString(d,"FR_DOWN", SWIG_From_int((int)(wxFR_DOWN)));
30263     }
30264     {
30265         PyDict_SetItemString(d,"FR_WHOLEWORD", SWIG_From_int((int)(wxFR_WHOLEWORD)));
30266     }
30267     {
30268         PyDict_SetItemString(d,"FR_MATCHCASE", SWIG_From_int((int)(wxFR_MATCHCASE)));
30269     }
30270     {
30271         PyDict_SetItemString(d,"FR_REPLACEDIALOG", SWIG_From_int((int)(wxFR_REPLACEDIALOG)));
30272     }
30273     {
30274         PyDict_SetItemString(d,"FR_NOUPDOWN", SWIG_From_int((int)(wxFR_NOUPDOWN)));
30275     }
30276     {
30277         PyDict_SetItemString(d,"FR_NOMATCHCASE", SWIG_From_int((int)(wxFR_NOMATCHCASE)));
30278     }
30279     {
30280         PyDict_SetItemString(d,"FR_NOWHOLEWORD", SWIG_From_int((int)(wxFR_NOWHOLEWORD)));
30281     }
30282     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
30283     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
30284     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
30285     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
30286     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
30287     {
30288         PyDict_SetItemString(d,"IDM_WINDOWTILE", SWIG_From_int((int)(4001)));
30289     }
30290     {
30291         PyDict_SetItemString(d,"IDM_WINDOWTILEHOR", SWIG_From_int((int)(4001)));
30292     }
30293     {
30294         PyDict_SetItemString(d,"IDM_WINDOWCASCADE", SWIG_From_int((int)(4002)));
30295     }
30296     {
30297         PyDict_SetItemString(d,"IDM_WINDOWICONS", SWIG_From_int((int)(4003)));
30298     }
30299     {
30300         PyDict_SetItemString(d,"IDM_WINDOWNEXT", SWIG_From_int((int)(4004)));
30301     }
30302     {
30303         PyDict_SetItemString(d,"IDM_WINDOWTILEVERT", SWIG_From_int((int)(4005)));
30304     }
30305     {
30306         PyDict_SetItemString(d,"IDM_WINDOWPREV", SWIG_From_int((int)(4006)));
30307     }
30308     {
30309         PyDict_SetItemString(d,"FIRST_MDI_CHILD", SWIG_From_int((int)(4100)));
30310     }
30311     {
30312         PyDict_SetItemString(d,"LAST_MDI_CHILD", SWIG_From_int((int)(4600)));
30313     }
30314     SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
30315     SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
30316     {
30317         PyDict_SetItemString(d,"PRINT_MODE_NONE", SWIG_From_int((int)(wxPRINT_MODE_NONE)));
30318     }
30319     {
30320         PyDict_SetItemString(d,"PRINT_MODE_PREVIEW", SWIG_From_int((int)(wxPRINT_MODE_PREVIEW)));
30321     }
30322     {
30323         PyDict_SetItemString(d,"PRINT_MODE_FILE", SWIG_From_int((int)(wxPRINT_MODE_FILE)));
30324     }
30325     {
30326         PyDict_SetItemString(d,"PRINT_MODE_PRINTER", SWIG_From_int((int)(wxPRINT_MODE_PRINTER)));
30327     }
30328     {
30329         PyDict_SetItemString(d,"PRINT_MODE_STREAM", SWIG_From_int((int)(wxPRINT_MODE_STREAM)));
30330     }
30331     {
30332         PyDict_SetItemString(d,"PRINTBIN_DEFAULT", SWIG_From_int((int)(wxPRINTBIN_DEFAULT)));
30333     }
30334     {
30335         PyDict_SetItemString(d,"PRINTBIN_ONLYONE", SWIG_From_int((int)(wxPRINTBIN_ONLYONE)));
30336     }
30337     {
30338         PyDict_SetItemString(d,"PRINTBIN_LOWER", SWIG_From_int((int)(wxPRINTBIN_LOWER)));
30339     }
30340     {
30341         PyDict_SetItemString(d,"PRINTBIN_MIDDLE", SWIG_From_int((int)(wxPRINTBIN_MIDDLE)));
30342     }
30343     {
30344         PyDict_SetItemString(d,"PRINTBIN_MANUAL", SWIG_From_int((int)(wxPRINTBIN_MANUAL)));
30345     }
30346     {
30347         PyDict_SetItemString(d,"PRINTBIN_ENVELOPE", SWIG_From_int((int)(wxPRINTBIN_ENVELOPE)));
30348     }
30349     {
30350         PyDict_SetItemString(d,"PRINTBIN_ENVMANUAL", SWIG_From_int((int)(wxPRINTBIN_ENVMANUAL)));
30351     }
30352     {
30353         PyDict_SetItemString(d,"PRINTBIN_AUTO", SWIG_From_int((int)(wxPRINTBIN_AUTO)));
30354     }
30355     {
30356         PyDict_SetItemString(d,"PRINTBIN_TRACTOR", SWIG_From_int((int)(wxPRINTBIN_TRACTOR)));
30357     }
30358     {
30359         PyDict_SetItemString(d,"PRINTBIN_SMALLFMT", SWIG_From_int((int)(wxPRINTBIN_SMALLFMT)));
30360     }
30361     {
30362         PyDict_SetItemString(d,"PRINTBIN_LARGEFMT", SWIG_From_int((int)(wxPRINTBIN_LARGEFMT)));
30363     }
30364     {
30365         PyDict_SetItemString(d,"PRINTBIN_LARGECAPACITY", SWIG_From_int((int)(wxPRINTBIN_LARGECAPACITY)));
30366     }
30367     {
30368         PyDict_SetItemString(d,"PRINTBIN_CASSETTE", SWIG_From_int((int)(wxPRINTBIN_CASSETTE)));
30369     }
30370     {
30371         PyDict_SetItemString(d,"PRINTBIN_FORMSOURCE", SWIG_From_int((int)(wxPRINTBIN_FORMSOURCE)));
30372     }
30373     {
30374         PyDict_SetItemString(d,"PRINTBIN_USER", SWIG_From_int((int)(wxPRINTBIN_USER)));
30375     }
30376     {
30377         PyDict_SetItemString(d,"PRINTER_NO_ERROR", SWIG_From_int((int)(wxPRINTER_NO_ERROR)));
30378     }
30379     {
30380         PyDict_SetItemString(d,"PRINTER_CANCELLED", SWIG_From_int((int)(wxPRINTER_CANCELLED)));
30381     }
30382     {
30383         PyDict_SetItemString(d,"PRINTER_ERROR", SWIG_From_int((int)(wxPRINTER_ERROR)));
30384     }
30385     {
30386         PyDict_SetItemString(d,"PREVIEW_PRINT", SWIG_From_int((int)(wxPREVIEW_PRINT)));
30387     }
30388     {
30389         PyDict_SetItemString(d,"PREVIEW_PREVIOUS", SWIG_From_int((int)(wxPREVIEW_PREVIOUS)));
30390     }
30391     {
30392         PyDict_SetItemString(d,"PREVIEW_NEXT", SWIG_From_int((int)(wxPREVIEW_NEXT)));
30393     }
30394     {
30395         PyDict_SetItemString(d,"PREVIEW_ZOOM", SWIG_From_int((int)(wxPREVIEW_ZOOM)));
30396     }
30397     {
30398         PyDict_SetItemString(d,"PREVIEW_FIRST", SWIG_From_int((int)(wxPREVIEW_FIRST)));
30399     }
30400     {
30401         PyDict_SetItemString(d,"PREVIEW_LAST", SWIG_From_int((int)(wxPREVIEW_LAST)));
30402     }
30403     {
30404         PyDict_SetItemString(d,"PREVIEW_GOTO", SWIG_From_int((int)(wxPREVIEW_GOTO)));
30405     }
30406     {
30407         PyDict_SetItemString(d,"PREVIEW_DEFAULT", SWIG_From_int((int)(wxPREVIEW_DEFAULT)));
30408     }
30409     {
30410         PyDict_SetItemString(d,"ID_PREVIEW_CLOSE", SWIG_From_int((int)(wxID_PREVIEW_CLOSE)));
30411     }
30412     {
30413         PyDict_SetItemString(d,"ID_PREVIEW_NEXT", SWIG_From_int((int)(wxID_PREVIEW_NEXT)));
30414     }
30415     {
30416         PyDict_SetItemString(d,"ID_PREVIEW_PREVIOUS", SWIG_From_int((int)(wxID_PREVIEW_PREVIOUS)));
30417     }
30418     {
30419         PyDict_SetItemString(d,"ID_PREVIEW_PRINT", SWIG_From_int((int)(wxID_PREVIEW_PRINT)));
30420     }
30421     {
30422         PyDict_SetItemString(d,"ID_PREVIEW_ZOOM", SWIG_From_int((int)(wxID_PREVIEW_ZOOM)));
30423     }
30424     {
30425         PyDict_SetItemString(d,"ID_PREVIEW_FIRST", SWIG_From_int((int)(wxID_PREVIEW_FIRST)));
30426     }
30427     {
30428         PyDict_SetItemString(d,"ID_PREVIEW_LAST", SWIG_From_int((int)(wxID_PREVIEW_LAST)));
30429     }
30430     {
30431         PyDict_SetItemString(d,"ID_PREVIEW_GOTO", SWIG_From_int((int)(wxID_PREVIEW_GOTO)));
30432     }
30433
30434     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
30435
30436 }
30437